Build a Windows slideshow application that runs persistently on a BeeLink EQ13, pulls images from a target directory (recursively), and displays them in random order. Think "digital picture frame on a desktop."
Python. The challenge: it has to compile to (or launch as) a single-file, one-click Windows executable. PyInstaller with --onefile is the standard path. Nuitka is the more interesting option if you want closer-to-native performance and a smaller binary.
GUI framework is your call.
Document the framework decision in the documentation.
Display behavior:
- Borderless window, NOT fullscreen
- Resizable from edges, snappable to Windows zones (Win+Arrow should work)
- Randomly cycles through images at a configurable interval
- Recursively scans a target directory for images (jpg, jpeg, png, webp, gif, bmp at minimum)
Controls (visible on hover, faded otherwise):
- Previous / Next
- Pause / Resume
- Remove current image from rotation
- Settings gear (corner of your choice) that becomes opaque when the cursor is near it
Settings pane:
- Change target directory
- Change slide duration (seconds)
- Exit the application
- Any other knobs you think belong there (shuffle vs sequential, supported file types, fit/fill/stretch behavior, etc.)
- Settings must persist between runs (JSON in
%APPDATA%is the path of least resistance)
Dynamic file detection:
The program must notice when new images are added to the target directory without needing a restart. Use watchdog (the idiomatic Python choice). Periodic rescan with timestamp comparison is acceptable as a fallback if you find watchdog flaky on a network share or similar edge case, but document the decision.
Startup:
Must be launchable on Windows startup. You can document the steps in the README rather than implementing it as a feature, or add a "launch on startup" toggle in settings (it's just a registry entry under HKCU\Software\Microsoft\Windows\CurrentVersion\Run, accessible via the winreg stdlib module).
- Smooth crossfade between images instead of hard cuts
- Configurable hotkeys (space = pause, arrows = nav, etc.)
- Per-image display duration override (e.g. for portraits vs panoramas)
- Persistent blacklist for removed images (survives across sessions)
- Multi-monitor awareness
- Memory-conscious image loading (don't load all 40,000 photos into RAM at once)
- A Windows executable produced via PyInstaller
--onefileor Nuitka equivalent - Source code in a git repo
- A README that explains:
- How to build it (full build command included)
- How to run it
- What settings exist and where they're stored
- Which GUI framework was chosen and why
- Which soft requirements you implemented and why
- Code organized enough that someone else could pick it up. Use type hints. Use a sensible module structure, not one 800-line file.
- Sensible error handling (what happens when the target directory disappears? when an image is corrupt? when the folder has zero images?)
- The UI doesn't have to be pretty, but it shouldn't actively look broken
- Don't over-engineer it. This is a slideshow, not a CMS.
- Document milestone completion dates and features as you get them working. These will be used for extra credit.
- Any other documentation you create during the development process to stay organized or help keep track of features and bugs.
Surprise me with something useful that isn't on this list. Doesn't have to be flashy, just thoughtful.
These are checkpoints, not suggestions. Show me what you've got at each one. If you're stuck, tell me before the due date, not on or after.
Milestone 1 (End of Week 1 - 5/30/2026): Working Skeleton
- Python project set up with virtualenv / poetry / uv (your choice), building to a runnable state
- A borderless window that opens and displays a single hardcoded image
- Directory scan that finds all images recursively and prints the count to the console
- Doesn't have to cycle yet. Just prove the foundation works.
Milestone 2 (End of Week 2 - 6/6/2026): Functional Slideshow
- Random image cycling at a fixed interval (hardcoded is fine)
- Previous / Next / Pause / Resume controls visible somewhere on screen
- Window is resizable and snaps to Windows zones
- No settings pane yet, no fancy hover behavior. It just has to work.
Milestone 3 (End of Week 3 - 6/13/2026): Settings + Persistence + Watcher
- Settings pane with target directory, duration, exit
- Settings persist between runs
watchdogdetects new images without restart- Hover-fade on the controls overlay
- Remove-from-rotation works
Milestone 4 (End of Week 4 - 6/20/2026): Polish + Ship
- At least two soft requirements implemented
- Published as a single-file Windows executable via PyInstaller or Nuitka
- README written
- Bonus item of your choosing
Total timeline: 4 weeks from start.
If you blow past a milestone date, that's a conversation, not a failure. But "I haven't started yet" the day before a Milestone is a failure. +1 point per day for finishing sooner for each milestone deadline. This means if you finish Milestone 1 on day 5 you get 2 points, and even if you fall behind on future deadlines, you still get those 2 points as long as it is documented.
You will be competing with your brother to see who can make the better slideshow that meets all criteria. He will be using C# with Avalonia or equivalent.
Total possible: 200 points base + bonus modifiers. Final score = base points earned + bonus modifiers - penalties.
Judged by Claude Code reviewing the repo, executable, and documentation. Language choice is not scored. Performance differences inherent to the language are not scored unless they materially affect the user experience (e.g. slideshow stutters, takes 10 seconds to load an image, eats 4GB of RAM idling).
Each item is binary: it works, or it doesn't. Partial credit only where noted.
| Item | Points |
|---|---|
| Borderless window, not fullscreen | 5 |
| Resizable from edges | 5 |
| Snaps to Windows zones (Win+Arrow works) | 5 |
| Random cycling at configurable interval | 10 |
| Recursive directory scan, handles all required formats | 10 |
| Previous / Next controls function correctly | 5 |
| Pause / Resume functions correctly | 5 |
| Remove-from-rotation works | 10 |
| Settings gear with hover-opacity behavior | 10 |
| Settings pane: change target directory | 5 |
| Settings pane: change duration | 5 |
| Settings pane: exit | 2 |
| Settings persist between runs | 10 |
| Dynamic file detection (watcher or rescan) | 15 |
| Launchable on Windows startup (implemented or documented) | 8 |
| One-click executable / single-file build | 10 |
| Item | Points |
|---|---|
| Code is organized and someone else could pick it up | 10 |
| Sensible error handling (missing directory, corrupt image, empty folder, watcher death) | 10 |
| No obvious crashes or hangs during 30 minutes of normal use | 10 |
| Item | Points |
|---|---|
| README with build instructions, run instructions, settings explanation | 10 |
| Roadmap or planning document (shows what was planned vs. what shipped) | 5 |
| Tech stack / architecture doc (what libraries, why, how the pieces fit) | 5 |
| Bug tracker or known-issues doc | 5 |
| Milestone completion log (dates each milestone hit) | 5 |
5 points per soft requirement implemented. Minimum 2 required (so 10 points is the baseline expectation, not a bonus).
A soft requirement only counts if it actually works. A half-broken crossfade that flickers or a "memory-conscious loading" implementation that still eats 2GB doesn't get the 5 points and may earn a penalty under "claims a feature works that doesn't."
| Item | Points |
|---|---|
| Early milestone completion | +1 per day per milestone, up to 4 days early |
| "Surprise me" bonus item that's actually useful | +5 to +15 (judge's discretion based on usefulness and execution) |
| Genuinely clever solution to a hard problem (e.g. snap zones, watcher debouncing, memory management) | +5 each, max +15 |
| UI feels polished and intentional, not just functional | +5 to +10 |
| Infraction | Points |
|---|---|
| Documentation exists but is incomplete or disorganized | -2 per document, max -10 |
| Required documentation completely missing | -20 |
| App crashes during evaluation | -10 per crash, max -30 |
| Settings file corrupts or fails to save | -10 |
| Has to be restarted to pick up new images (watcher broken) | -15 |
| Code has obvious copy-paste duplication or dead code | -2 per instance, max -10 |
| README claims a feature works that doesn't | -10 per claim |
| Repo is messy (uncommitted junk, no .gitignore, build artifacts checked in) | -5 |
| Missed milestone deadline without communication | -5 per milestone |
If scores are within 10 points of each other, the tiebreaker is subjective "which one would you actually want to run on the BeeLink full-time." Judged by Claude Code and Dad based on perceived polish, reliability, and how much it feels like a real product vs. a school project.