DEV Community: Dmytro Voytko

🕯️ Lumina: Realms of Remembrance & Lore -educational Halloween-adjacent arcade 👻

Dmytro Voytko — Thu, 29 Oct 2026 16:04:30 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

🕯️ Lumina: Realms of Remembrance & Lore is a browser-based educational trivia arcade that treats Halloween as two traditions worth learning from, not one.

The Challenge theme asked for something spooky, Halloween-adjacent, or in the spirit of Día de los Muertos. I chose "all of the above" and made the duality the whole point. Lumina ships with three playable realms:

El Camino de los Recuerdos — Día de los Muertos through real Nahua cosmology (Mictlán, Mictecacihuatl, the Cihuateteo), the four elemental offerings (salt, water, copal, papel picado), the botanical chemistry of cempasúchil marigolds, Posada and Rivera's La Catrina, and Purepecha candlelit vigils on Lake Pátzcuaro.
The Alchemist's Crypt — Halloween as science. Samhain harvest markers, Pepper's Ghost optics and 45° specular reflection, bat echolocation and moth counter-clicks, tapetum lucidum night vision, pumpkin beta-carotene, and medical debunkings of vampire and werewolf lore (porphyria, ergotism, rabies).
The Liminal Crossroads — a hybrid mode that alternates between both, asking players to hold two cosmologies at once.

The core loop is a ticking candle survival engine. An animated SVG candle is your life bar: correct answers replenish the flame, mistakes puff smoke and cost seconds, and streaks (3x/5x/10x) trigger luminous flares and harmonic fanfares. It's a game about keeping a light alive while learning why we light it.

There are 60 pre-seeded, culturally vetted questions (36 four-choice + 24 Myth-vs-Fact), three difficulty tiers, a Certificate of Luminous Attainment gated at 50% with printable/PDF export, a "Knowledge Digest" session recap, and an in-app Codex Explorer for reading every fact outside of gameplay.

I wanted the "spooky" to be the hook and the education to be the payload — the scariest thing in Lumina is how much of the folklore turns out to be chemistry, biology, and history.

Demo

Live demo: https://dmytrovoytko.github.io/lumina-spookyedu/

Trivia & candle timer

Candle pressure & time limits

Knowledge base - Codex of Remembrance & Science

Certificate of Luminous Attainment

The demo runs fully offline on GitHub Pages — no backend, no login, no API key required.

Code

Repository: github.com/dmytrovoytko/lumina-spookyedu

Highlights worth a look:

src/components/AIQuestionGeneratorModal.tsx — optional LLM question generation with a local fallback synthesizer.
src/components/CandleHUD.tsx — the SVG candle survival/timer engine.
src/data/triviaBank.ts — the 60 vetted Día de los Muertos / Halloween science questions.
src/utils/audio.ts — the procedural Web Audio sound design (zero audio files).
.github/workflows/ — static build + GitHub Pages deploy.

How I Built It

Stack: React 19 + TypeScript, Tailwind CSS v4, Vite, Lucide React, and the native Web Audio API. It builds to a 100% static bundle with 16 unit tests via tsx --test.

The open-weight model: Lumina's content is pre-seeded and offline-first, but the Infinite AI Question Generator lets players expand the deck on demand. When a user supplies an API key, it calls an open-weight Gemma model — gemma-4-31b-it in the current build (swappable for gemma-4-26b-a4b-it or gemini-3.5-flash via a single line in AIQuestionGeneratorModal.tsx). The prompt asks the model to return strict JSON trivia cards with an explanation and a source/context field, so generated content stays in the same educational format as the curated bank.

The important design choice: the model is an enhancement, never a dependency. If there's no key, no network, or the request fails, the app falls back to a local procedural synthesizer, so the GitHub Pages demo stays fully functional. That's deliberate — an educational artifact shouldn't break because an API quota did.

Why Does Open Innovation Matter?

Open innovation made the shape of this project possible, not just its cost.

First, open-weight models let me put a frontier-ish model behind a static site with no proprietary backend and no vendor lock-in. A visitor can bring their own key, or none at all, and the experience degrades gracefully. That portability is only possible because the model is open and callable on my terms.

Second, open tooling made the whole thing reproducible: Vite, React, Tailwind, the Web Audio API, and a GitHub Actions workflow mean anyone can fork Lumina, change a question, swap the model, and redeploy to their own Pages URL. A closed-API product would have locked the content pipeline behind someone else's dashboard.

Third, and most importantly for this theme: cultural knowledge should be inspectable and remixable. Día de los Muertos is living heritage, and the best guard against flattening it into decoration is a codebase where the sources, explanations, and question logic are all visible and editable. Open source lets educators, families, and communities correct and extend the material — which a black-box API never could.

Lumina is my small argument that spooky and sacred can share a candle 🕯️ and that the light should belong to everyone.

🎃💀 Have fun! 👻

Smart Feed Filter: Tuning My RSS Digest with a Local JEV-like model in Ollama

Dmytro Voytko — Sun, 25 Oct 2026 18:39:33 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Smart Feed Filter turns public RSS feeds into a short, category-grouped digest for one person.

The problem: professionals with RSS still drown in unread items, and generic readers sort by recency while AI summarizers add reading work instead of removing it.

Smart Feed Filter removes the triage step. You define a profile: a small set of categories, each with a name, description, criteria, and weight. A local decision model scores every feed item against those categories. The app shows the last 72 hours grouped by category, ranked inside each category, with tags and (optionally) a one-line reason.

It's a filtering engine, not a summarizer. No article fetching, no private accounts, no generated prose.

Who gets a little more relaxed, or lazier? The data scientist who wants to skim only ML-method papers and skip hiring/funding noise; the off-work reader who wants hobby content without the feed becoming an everything feed.

Workflow

Smart Feed Filter's workflow in two steps:

the user defines a profile of weighted categories with plain-language criteria,
then hits refresh to fetch and dedupe public RSS feeds while a local Ollama decision model scores each new item against the enabled categories, producing a 72-hour digest grouped and ranked by category.

User defines profile (categories, criteria, weights)
        │
        ▼
Manual refresh → fetch → dedupe → store
        │
        ▼
Local classifier (Ollama) scores new items
        │
        ▼
72h digest grouped by category, ranked by score

Demo

Here are screenshots of the running app:

Smart Feed categorization processing

Digest grouped by category, ranked items with match confidence

Digest grouped by category, collapsed, including Low confidence group and sources

Code

GitHub repo structure

├── app
│   ├── config.py
│   ├── db.py
│   ├── __init__.py
│   ├── logging_config.py
│   ├── __main__.py
│   ├── main.py
│   ├── routes/
│   ├── schema.sql
│   ├── seed.py
│   ├── services/
│   ├── static/
│   ├── templates/
│   ├── timeutil.py
│   └── versioning.py
├── data
│   └── feedfilter.db
├── eval/
├── profiles
│   ├── catalog.yaml
│   ├── ds.v1.yaml
│   └── fun.v1.yaml
├── pyproject.toml
├── requirements.txt
├── spec.md
└── tests/

How I Built It

Python 3.12+, FastAPI, Jinja2 + HTMX, SQLite WAL, feedparser, requests, PyYAML, pydantic, python-dateutil, uvicorn.
Local decision model via Ollama: model tev1:0.8b (fallback tev1:4b), POST /v1/systemone.
State = title + summary, truncated to 1200 chars word boundary; no article fetching; no HTML.
One noul question per enabled category per item; up to 16 categories.
Threshold by profile, 0.55 default; match when probability ≥ threshold; low confidence collapsed by default.
Ranking: probability × weight × recency decay; 72h window; dedupe canonical URL + normalized title; retention 30 days.
Retroactive edits: preview re-scores last 14 days, atomic apply, cancel discards.
Error handling: persisted job state, actionable banner (ollama serve, ollama pull tev1:0.8b), retry classifies only missing.

Reasons are templated, never generated. Ranking handles ordering. Retroactive edits use a preview-diff-then-atomic-apply flow over the last 14 days; weight edits reorder without model calls, threshold edits re-filter cached probabilities.

Before building UI, I ran a model gate via python eval/harness.py --gate: a 100-item labeled set (50 per profile) scored on macro-F1, precision@10, latency, and failures. The local tev1:0.8b model passed my selection after category and threshold tuning; fallback tev1:4b documented.

The hard part

Categorizing work content was (is?) harder than off-work (fun) content because real-world topics overlap heavily (ML methods vs. LLM apps vs. MLOps vs. experimentation), which is exactly why the spec encodes separate criteria fields and why ds.v1 needed more tuning cycles than the fun profile.

Here is the sample of ds.v1 profile:

id: ds.v1
name: Data Scientist
kind: work
version: 1
threshold: 0.62
max_categories: 16
seed: true
description: >
  Professional reading profile for data scientists and ML practitioners.
  Prefers methods, production practice, analytics, and responsible AI over
  general technology news, hiring, funding, and product marketing.
exclude_hints:
  - hiring, recruiting, and career advice
  - funding, acquisitions, and business news
  - consumer gadgets and general technology policy
  - health or medical advice
categories:
  - id: ml-research
    name: ML Methods & Research
    description: >-
      New machine-learning methods, architectures, training techniques,
      benchmarks, or results from research papers and research labs.
    criteria_true: >-
      The item reports or analyzes a machine-learning method, model, benchmark,
      training technique, or research finding.
    criteria_false: >-
      The item is product news, production operations, business news, career
      advice, or not about machine-learning methods.
    reason_hint: covers methods, architectures, benchmarks, or research findings
    weight: 1.3
    enabled: true

Each category can be enabled/disabled. So for example you can be interested in some topic like "Responsible AI & Evaluation", and after getting enough valuable information just turn it off - until you need it again. Similarly with job search and vacancies - your job-search profile can include categories for different positions with their own criteria.

Why Does Open Innovation Matter?

Open innovation made this build possible in a way a closed API never could. The intelligence here isn't a black box you call — it's a local model plus an open taxonomy loop: versioned category criteria, eval harness, gate, threshold tuning, and preview diffs. Opening the criteria (criteria_true / criteria_false, reason hints) meant the taxonomy itself became community- and maintainer-editable, versioned via hash.

And because the model runs locally on an open-weight model via Ollama - local-first means no vendor lock-in. Privacy wasn't an afterthought — it was the architecture: no API key, no telemetry, nothing leaving the machine except public feed requests. Open source made that stack reproducible.

🎬 YouTube Insight Extractor

Dmytro Voytko — Mon, 19 Oct 2026 06:43:05 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Long-form YouTube is where the best ideas live — Tim Ferriss, Huberman, Diary of a CEO — but a two-to-three-hour interview buries a handful of personally relevant insights inside hours of conversation. Watching the whole thing to find them is why people give up.

YT Insight Extractor turns a YouTube link into a focused, timestamped action plan. You paste a URL, pick an Area of Life (Career, Fitness, Finance, Productivity…), and optionally describe a goal. The app returns two tabs — subtopic summaries and actionable ideas — each anchored to a clickable timestamp that jumps to the exact moment in the video. Results export to Markdown or JSON and are saved to a local history with 👍/👎 feedback.

Who would pay for it? Self-directed learners, coaches, and creators who consume hours of long-form content weekly and want signal, not another bookmark.

Demo

No public deployment — deliberate. YouTube blocks cloud-provider IPs, so a hosted demo would fail at the transcript step. Instead the repo ships a local-first app you run yourself:

Insights — staged pipeline UI (extract transcript → chunk & vectorize → RAG & summarize) with per-step status, then the two result tabs with clickable timestamps.

Configuration — switch LLM provider at runtime (local Ollama default; BYOK cloud optional).

History — every run saved locally, with feedback buttons.

Report Dashboard — usage KPIs: runs, goals, latency, distributions by area, LLM, and feedback.

Code

YT Insight Extractor repo on GitHub

app.py orchestrates core/, with each pipeline stage a small, independently testable module: core/rag_engine.py (retrieval), core/hybrid.py (RRF fusion), core/generator.py (schema-constrained output), core/prompts.py (v1/v2 prompts), plus offline evals in scripts/. Tests: python -m unittest discover -s tests/ (200 tests).

How I Built It

The stack is open-source end to end. Embeddings: ONNX all-MiniLM-L6-v2 via onnxruntime — chosen over sentence-transformers to avoid ~800 MB of PyTorch and stay runnable on a CPU laptop in a small container. Vector store: in-memory ChromaDB wrapped by LlamaIndex. Generation: schema-constrained output via Pydantic, defaulting to local Ollama llama3.2:1b, plus BYOK cloud models. Retrieval: vector | keyword | hybrid, where hybrid uses reciprocal-rank fusion written with the standard library — no new dependencies.

Why Does Open Innovation Matter?

Every meaningful constraint here was solvable only with open tooling. A closed API can't be pointed at a local Ollama model, can't ship ONNX weights instead of a torch dependency, and can't run entirely on your machine — no transcript, goal, or output leaving your laptop. When YouTube closed its public endpoints, the project didn't die; it adapted, because I owned the retrieval layer, not just a prompt. And because the models and evals are open, anyone can reproduce the numbers.

🧭 StrideHunter: transform daily walks and runs into quests

Dmytro Voytko — Sun, 11 Oct 2026 22:40:04 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

StrideHunter is a free, open, install-free scavenger hunt PWA. An organizer (parent, teacher, team lead — or just you, for yourself) describes a place, picks walk/run, effort level, and quiz count, and gets a complete outdoor quest: point-tiered missions (50/150/300), POI quiz stops with typo-tolerant answers, a 500-pt golden finale, countdown with speed bonus. Players scan one QR code — no account, no app install — and go outside to play it.

It's for three cravings I kept seeing:

desk workers who sit all week and need a reason to move,
hosts who want to take a crew outside without planning for hours, and
teen squads who'll go anywhere if it's a game.

The phone becomes a compass, not a couch: missions only resolve out there — photos at viewpoints, quiz answers in front of statues, GPS check-ins at bonus stops.

Features

Choose your effort: Chill / Normal / Beast, plus walk / run modes and time-of-day adaptation
AI quest generation (BYOK OpenRouter or local Ollama): point tiers 50/150/300/500, golden mission, POI quiz stops with lenient typo-tolerant answers
Outdoor-proof play: GPS “you’re close” hints with honor fallback, countdown + speed bonus, offline PWA after first load
Honest sharing: the link carries the whole quest (capped, trimmed, QR-friendly); draft → edit gate → publish flow
Privacy-first: no accounts, no analytics; hunt data lives in the link, API keys stay in your browser (session-only unless you opt in)

Demo

Generate	Dark theme, mobile

Live demo: StrideHunter app is deployed via GitHub Pages.

Try the zero-setup demo hunt first — no key needed - just scroll to the bottom and click "Try demo instead" button.

Code

GitHub repo: 🧭 StrideHunter

index.html        tabs (Generate / Share / Play) + settings drawer
css/style.css     theme vars, dark mode, 44px touch targets
js/app.js         everything (~1200 lines, plain scripts, zero build)
js/prompts.js     prompt templates (effort/quiz/weather/fallback branches)
sw.js             offline PWA (dev default OFF)

The core trick is the share link — the entire quest lives in the URL hash, so there's no backend to run.

And the AI output is never trusted blindly: JSON is extracted from plain model text, validated, organizer-approved in a preview gate — plus an unverified flag (gated in code, so models can't self-apply it) marks anything the AI guessed while map data was down.

How I Built It

Open-weight models, BYOK style: generation runs on open models ( google/gemma-4-31b-it, or free Nemotron) through OpenRouter with your own free key — or fully local via Ollama. Deliberately no structured-outputs requirement: the app parses JSON out of plain text, so any instruction-following model works, free or paid.
Zero-build vanilla JS on free static hosting (GitHub Pages): no framework, no bundler, no server. If it can't be served from a static folder, it doesn't ship.
Open data instead of a POI vendor: OpenStreetMap (Overpass/Nominatim) + Open-Meteo, with endpoint fallbacks, caching, and request politeness baked in after real-world 504s taught us respect.
Open libraries, vendored: QR encoder, confetti — pinned locally, working offline.
Open process: prompt templates live in the repo, no telemetry, tracking, etc.

Why Does Open Innovation Matter?

Honestly? This project exists because everything was open.

No budget meant no POI vendor — OSM's free data plus three public mirrors (with fallbacks I only needed because they were transparent about their limits) replaced a contract.
No AI budget meant BYOK open-weights instead of a platform lock-in — and designing for “any model that emits JSON” made the app more robust than a single-model integration would be.
No backend budget meant inventing the self-contained share link, which turned into the best feature: private-by-architecture (your hunt never touches my server, because there isn't one), offline-capable, and forkable by anyone — clone the repo, serve the folder, run the demo with zero keys.

Openness wasn't the theme of this build. It was the building material.

Flashcard Pro — DP-600 Exam Trainer

Dmytro Voytko — Mon, 05 Oct 2026 06:56:45 +0000

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

What I Built

Flashcard Pro — DP-600 Exam Trainer, built for my friend Den who is preparing for the Microsoft DP-600: Implementing Analytics Solutions Using Microsoft Fabric exam.

Den was drowning in Fabric docs — lakehouses, warehouses, KQL, DAX, governance — with no good way to do active recall. So I built him a simple Flask study app:

Pick a mode + topic → see a term → try to recall → reveal definition → self-grade Yes/No → next card.

202 cards across all 8 DP-600 topics, in one merged flashcards.json
Modes: Any / New / Incorrect / simple / intermediate / advanced + per-topic filter
/stats dashboard: accuracy overall, by topic, by difficulty
JSON file storage, no DB, runs locally in 10 seconds
Results log with auto-compaction + 7 unit tests

Problem it solves: turns passive reading into spaced, self-tested review — especially re-drilling the cards he gets wrong.

Demo

Live local run: pip install -r requirements.txt && python app.py → http://127.0.0.1:8001/

Screenshots instead of video:

Home: mode + topic picker with progress summary

Quiz: term → Show Definition → Yes/No self-grade

Stats: overall / by-topic / by-difficulty accuracy

Full flow: Home → Start Study (e.g. incorrect + Topic 5) → Quiz loop → Session Complete! → Stats.

Code

https://github.com/dmytrovoytko/flashcards

Stack: Python + Flask + Jinja + Bootstrap 5, app.py for routes/session, data_manager.py for filtering/stats/compaction, templates/index.html, quiz.html, stats.html.

How I Built It

Built agentically with open-source AI:

Model: google/gemma-4-31b-it — used for codebase analysis, spec writing, and implementation
Harness: OpenCode coding agent — Task/Todo-driven edits, test runs, verification via python -m unittest
Frameworks: Flask 3, Bootstrap 5.3, stdlib json
Local-first: all inference-assisted coding + all app data runs locally — cards, topics, and results.json never leave the machine

The AI did what it's best at: brainstormed the specs and made key decisions, generated flashcards by topics and difficulty (simple/intermediate/advanced in data), merged flashcards1-8.json → flashcards.json, fixed the filter, then implemented the suggested roadmap: topic picker, /stats, /end, stale-ID skipping, SECRET_KEY/FLASK_DEBUG/PORT env config, requirements.txt, and test_data_manager.py.

Why Does Open Innovation Matter?

This project only works because it's open:

Forkable study content: anyone can PR new cards for DP-700, AZ-104, etc. A closed API with proprietary quizzes wouldn't allow that.
Inspectable learning logic: Den can read get_filtered_cards() and get_stats() and trust how "incorrect" and accuracy are computed.
Self-hostable + private: exam prep progress stays in a local results.json, no tracking, no subscription — perfect for Hacktoberfest-style community contributions.
Open models → open builders: I could reproduce this entire workflow with an open-weight assistant in OpenCode, iterate locally, and push back to GitHub for others to reuse.

Open innovation turned a one-off favor for Den into a template anyone can clone for any certification.