Stardance Challenge Devlog 1: Finding the “Just Right” Balance with eceWire

The Vision: Khan Academy Meets IXL

Welcome to my very first devlog for the Stardance Challenge! With eceWire, I am setting out to solve a major user experience and pedagogical problem in modern digital education. When analyzing the current web landscape for online learning tools, I noticed a frustrating, extreme divide between two massive platform philosophies:

1. Khan Academy: Offers brilliant, deep lesson contexts, conceptual explanations, and rich structural layouts. However, it can feel painfully slow, over-reliant on sitting through long videos, and sluggish when you just want to jump in and build core muscle memory.
2. IXL: Blazing fast and gets straight to the point with continuous question drilling loops. However, it completely lacks pedagogical depth. It can feel like a cold, repetitive question mill that flags answers without offering actual real-time teaching.

I wanted to engineer a platform that sits “just right” directly in the middle. It steals the deep, visually rich lesson content cards of Khan Academy and marries them natively to the rapid-fire, low-latency practice engines of IXL. To prove this hybrid architecture works, I built a fast single-page web prototype running entirely inside a single index file, loaded with comprehensive environments for Pre-Algebra, Honors Geometry, and Arduino hardware engineering.

Font and UI Design System

To ensure students can focus during intensive, late-night study sessions without suffering severe eye strain, I built out a sleek obsidian layout system using strict custom style tokens.

• Typography Foundations: The application imports and relies on a balance between standard headers and readable body text. Body components use clean geometric sans-serif configurations to keep long technical reading clear, while primary layout headers utilize a heavy serif display style via @import url('https://fonts.googleapis.com/css2?family=DM+Serif+Display&family=DM+Sans&display=swap').
• The Obsidian Color Scheme: Deep Background uses a space-cadet navy blue (#0c0f1a) that keeps overall contrast soft. Elevated Cards use layered surfaces (#131728) to distinctly separate text blocks from interactive sandbox segments.

Core Tracks: Pre-Algebra, Honors Geo, and Arduino

Pre-Algebra (117+ Skills)

Focuses on establishing core numerical mastery before students advance into structural equations. Students are presented with direct, high-speed input elements evaluated instantly by the runtime engine to maximize rapid skill absorption.

Honors Geometry (280+ Skills)

Brings heavy spatial concepts to life by rendering customized coordinate vector blocks (.svg-wrap). This setup lets students view visual definitions—like calculating polygon interior angles or managing coordinate focus proofs—right next to their practice area.

Arduino Physical Computing

Structures embedded syntax wrappers specifically tailored for microcontrollers. Students can review exact code arrays for setup routines (void setup()) and loops (void loop()) alongside circuit schematics to master software-hardware logic simultaneously.

Teaching in Action and Student Response

I actively use this platform to teach my students, and the response has been incredible. They absolutely love the hybrid layout. Students can study textbook definitions at their own pace on the “Learn” side, then switch to “Practice” to drill concepts without experiencing browser lag.

When a student achieves a score of 60% or higher, the data engine updates the user profile instantly:

if (curSkill && pct >= 60) {
  setDone(curSkill.ui, curSkill.si);
  updateProgress();
}

Mintyboy Devlog — Feature Expansion
Overview
Mintyboy has evolved from a basic handheld into a small multi-purpose system. It now combines games, utilities, and live data features on a single ESP32 with a 1.96 inch TFT display.
The main focus recently has been expanding functionality while keeping everything responsive and usable on very limited hardware.
Games
The games system has grown a lot and is now one of the core parts of Mintyboy.

2048

Tetris

Pong

Flappy Bird

Snake

Breakout

Minesweeper

Simon Says

Challenges
The biggest challenge across all games is performance and memory. The ESP32 isn’t powerful in terms of graphics, so everything has to be drawn efficiently.

Tetris required a full grid system, rotation logic, and line clearing without slowing down rendering

Minesweeper needed a hidden tile system, recursive reveals, and flag handling, which added complexity fast

Flappy Bird was mostly about tuning physics and timing so button input felt responsive and fair

Snake and Pong were simpler but still required smooth updates without flickering

Another issue was keeping a consistent input system across all games. Since everything uses the same buttons, the controls had to feel natural in every game without rewriting input logic each time.
Calculator
The calculator is a small feature but surprisingly tricky to implement properly.

Supports basic math operations

Displays a full expression before evaluation

Shows results clearly on screen

Challenges
The biggest issue was input navigation. Without a keypad or touchscreen, selecting numbers and operators using buttons can feel slow if not designed well.
Handling edge cases like multiple operations, clearing input, and preventing invalid expressions also needed extra logic.
UI layout was another constraint, since everything has to fit on a very small screen without becoming confusing.
News Feature
The news system pulls live headlines from a BBC RSS feed.

No API key required

Uses HTTP requests

Parses XML data

Displays headlines in a scrollable format

Challenges
Parsing XML on an embedded device is not ideal. Memory usage becomes a problem quickly, so the system only extracts the necessary parts instead of storing the full response.
Text formatting was another issue. Headlines can be long, so they need to be wrapped correctly to fit the TFT display without cutting off words awkwardly.
There’s also the delay from network requests, which had to be handled so the UI doesn’t freeze while loading.
Stocks Feature
The stocks feature is one of the most complex systems so far.

User inputs a ticker symbol

Fetches data from Yahoo Finance

Displays current price

Renders a small price chart

Challenges
Handling API responses was the first hurdle. The data needs to be parsed and reduced to only what’s necessary.
Drawing the graph was the hardest part. Since there’s no charting library, everything is done manually:

Normalize price data

Scale it to screen size

Draw lines between points

Another issue was keeping the graph readable on such a low-resolution display. Too much data makes it messy, so it had to be limited and simplified.
System Integration
As more features were added, managing the overall system became harder.
Challenges

Avoiding blocking code so the device doesn’t freeze

Managing memory between games and network features

Keeping the UI consistent across completely different apps

Handling transitions between menus and features cleanly

Even simple things like switching between apps required structure to prevent crashes or glitches.
System State
Current features:

Games system with multiple titles

Calculator

News reader (RSS-based)

Stock tracker with chart rendering
What else should I add guys??

Hi guys!

I’ve been working for 24 hours on this project and the new features are perfected

New:
• Flappy Bird
• Timer/Stopwatch

• Flappy Bird - I’ve added another classic game to this: Flappy Bird! There still needs to be some tweaks to this, as once you click the button, it will leave a little mark once it goes up, but other than that, EEPROM and everything work!

•Stopwatch - Neat feature that I thought may be helpful in the real world, it does work and can save your time!

What next?

• I’m thinking of adding a world clock. I would need to design the app, link it to the Arduino Nano ESP32, and then display. Let me know what you guys think!

PICO-DINO just jumped on a cactus 😭😭

…the PicoDino tries to jump over the EVIL CACTUS, but he lands perfectly on it!

RIP PicoDino 🪦🦖

.
.
.

But…

Cactus collision is working! 😎

Finally, the dino can’t go through cacti anymore!

I implemented a mask collision system to check if the dino and the cactus are colliding.

What is this project?

The PICOLATOR is a custom OS for the Pico 2W. I am planning to implement games, apps, but also internet-related projects!

P.S. - I finally figured out how to add multiple photos 😅

Devlog: NASA Feature (Mintyboy)
🌌 Overview
The NASA feature turns the Mintyboy from just a game console into a space exploration device. It combines real-world NASA data with a retro UI, letting users explore planets, missions, and daily space content directly from the device.

Planets & Moons Explorer

Added a scrollable menu system for planets

Each planet includes:

1. Name

2. Basic info

3. Major moons (e.g., Europa, Titan, Luna)

Designed to work smoothly on limited hardware

Keeps everything lightweight and readable on a small screen

This feature gives the Mintyboy a mini solar system database. ______________________________________________________________________________Artemis II Mission

Added a dedicated section for Artemis II

Highlights:

1. First crewed mission of the Artemis program

2. Mission goal: orbit the Moon and return safely

3. Acts like a featured story inside the NASA menu

This connects the Mintyboy to real, modern space exploration. ______________________________________________________________________________ APOD (Astronomy Picture of the Day)

Uses WiFi to connect to NASA’s APOD API

Displays:

1. Title

2. Short description

Images are simplified due to hardware limits; the TFT screen cannot display an image that is in APOD

This makes the device feel dynamic, like it’s updating with new space content daily (which it kinda is)

Challenges: Fitting large astronomy data into a tiny display

Managing memory limits

Parsing API responses efficiently

Keeping UI smooth alongside games

Final Result
The NASA feature transforms the Mintyboy into:

A game console

A learning tool

A space exploration hub!

Hi guys!

I’ve been working for 24 hours on this project and the new features are perfected

New:
• Flappy Bird
• Timer/Stopwatch

• Flappy Bird - I’ve added another classic game to this: Flappy Bird! There still needs to be some tweaks to this, as once you click the button, it will leave a little mark once it goes up, but other than that, EEPROM and everything work!

•Stopwatch - Neat feature that I thought may be helpful in the real world, it does work and can save your time!

What next?

• I’m thinking of adding a world clock. I would need to design the app, link it to the Arduino Nano ESP32, and then display. Let me know what you guys think!

Devlog - 03

A Curiously Minty Gameboy

Officially, I’ve given my project a name: The Minty Boy!

I call it that because it’s not just a regular Gameboy, it has a little “kick” to it, like a mint.

Instead of just running the 3 regular games: 2048, Tetris, and Pong, it can now send messages and display the weather accurately; moreover, I’ve added the feature where it can track your IP address and find out what the weather is in your location, and on the home screen, display the date/time of your location (according to the IP Address).

This project is reaching the end.

The end of the prototype, of course.

This is just the beginning of the Minty boy.

Devlog -02

A Curiously Minty Gameboy

This is probably one of my favorite builds so far—a tiny, Altoids powered “Gameboy” that somehow turned into a full-on mini gaming system.

What started as a simple project with an Arduino Nano quickly got an upgrade. I switched over to the Arduino Nano ESP32, and that change honestly unlocked everything. With more power, built-in WiFi and Bluetooth, and way more flexibility, the project went from “cool gadget” to something that actually feels like a real handheld console.

On the software side, I’ve packed in a bunch of classic games:

2048 (which took forever to get smooth and responsive)
Tetris (definitely the most satisfying one to play)
Pong (simple, but it just feels right on this device)

But the part I’m most proud of isn’t even the games—it’s the settings system. I built out a full menu where you can actually customize the device like a real piece of tech. Inside settings, you can:

Connect to WiFi

Use Bluetooth

Switch between light and dark mode

And even clear all saved data if you want a fresh start

That’s something I didn’t originally plan, but once I started adding features, it just made sense to treat it like a real OS instead of just a game launcher.

Hardware-wise, everything is crammed into an Altoids tin, which makes it feel super compact and kind of ridiculous in the best way. There’s still some tweaking left—mainly refining controls and polishing the UI—but it’s at the point where it’s fully usable and actually fun.

Overall, this project taught me a ton—not just about Arduino and ESP32, but about designing systems, managing features, and turning a small idea into something way bigger than I expected.

Devlog - 01
A Curiously Minty Gameboy😏

Using an Altoids tin and an Arduino, I’ve been building a fully functional mini “gameboy,” and I’m now at the point where the project is almost complete. Over the past few days, I’ve put in a lot of time refining the code, especially working on the 2048 game feature. I’m thinking about adding Pong and Tetris at this stage. After a long stretch of late-night debugging and tweaking, I finally have the game running smoothly on the display, which feels like a huge accomplishment.

At this stage, most of the core functionality is finished, and everything is coming together exactly how I imagined. The display works, the logic behind the game is solid, and the overall structure of the code is nearly finalized. The main thing left to polish is the pushbutton input system, since the controls still need to be a bit more responsive and reliable.

Once I fix that, the project will essentially be complete, and I can focus on final touches like optimizing performance and maybe adding a few extra features. It’s been a challenging but super rewarding experience, and I’m really close to having a fully working Arduino-powered “phone” inside an Altoids tin.