nubprogrammer

🛠️ Devlog #2 — Giving LagLore a Face (2h 05m)
Today’s session was all about bringing LagLore to life visually.
After locking in the core concept — Mr. Laggy testing players through unstable trials — I spent time translating that idea into actual game assets. This meant designing a full pixel-art character set for Mr. Laggy, covering multiple emotions and states so he can feel present across every trial rather than just being a static mascot.

Alongside the character work, I designed sprite assets for each individual trial — UI elements, game-specific components, and meta progression icons like ranks, trophies, and trial states. The goal was consistency: every game should feel like part of the same universe, not disconnected demos stitched together.

One challenge was designing assets that feel dynamic even before animation. Since these are browser-based games, the sprites needed to work well with lightweight animation techniques like frame swapping and CSS transforms, without relying on heavy engines.

By the end of the session, LagLore finally felt like a real game world rather than a concept. With the full visual foundation in place, the next step is implementing the first playable trial and wiring progression and leaderboards on top of these assets.

Devlog — LagLore (Ideation & Setup)

Spent this session laying the foundation for LagLore, a non-static web-based strategy game built around asynchronous gameplay and delayed outcomes. The core idea is to make time itself a mechanic — players don’t need to be online simultaneously, and decisions unfold over real-world time rather than instant reactions.

The focus today was ideation and structure rather than heavy feature work. I finalized the project concept, defined the scope to keep it manageable, and planned the architecture so future development doesn’t turn into a refactor nightmare.

On the technical side, I set up a lightweight web stack:

Frontend: HTML, CSS, and JavaScript (no heavy frameworks yet)

Hosting: Vercel for fast iteration and zero-config deployments

Version Control: GitHub for clean history and incremental shipping

I also created an initial “Coming Soon” landing page to establish a live demo endpoint early. This helps with visibility, quick feedback, and makes sure deployments are working before the game logic grows more complex.

Structurally, the project is designed to scale in phases:

Static landing & concept validation

Core game loop (client-side)

Persistence layer (lightweight backend / database)

Multiplayer & asynchronous mechanics

What I’m most proud of here is resisting the urge to overbuild early. Keeping the setup simple makes it easier to iterate fast, avoid burnout, and actually ship features instead of fighting tooling.

Next up: implementing the first interactive gameplay prototype and visual identity for LagLore.

Devlog #2 — UI groundwork & structure

⏱ Time spent: 2h 2m

In this session, I focused on laying down the core UI and internal structure for TermFlow.

What I worked on

Built the initial terminal UI in Python

Structured the project files cleanly so future features are easy to add

Designed the layout for:

Todo list panel

Pomodoro section

Info panel (weather + quotes)

Integrated a quote system (currently static/random, will refine later)

Current state

The UI renders correctly and is stable

Navigation and interaction are not fully wired yet

This session was mainly about visual structure and foundations, not behavior

What’s next

Make the UI fully interactive (keyboard-first)

Fix layout edge cases (help/info panels)

Add a command palette for quick actions (planning phase)

Improve data handling and persistence

This project is still actively evolving. I’ll be iterating on interactivity and polish in the upcoming sessions.

Stay tuned for more devlogs 👀
Follow along as TermFlow grows into a full terminal-first productivity tool.

Day 1 — SynapseBeats

Today I set up the SynapseBeats project for public tracking and started the Flavortown submission.

What I did:

• Configured Hackatime/WakaTime and verified heartbeats from VS Code.
• Linked my GitHub repo (https://github.com/Nub-programmer/SynapsebeatsSRC) to Hackatime.
• Cleaned up project root structure and added a .wakatime-project to ensure correct tracking.
• Reviewed the codebase (src/ folder): command handlers, events, plugin structure, and Lavalink connection logic.

Next steps:

• Improve README, add screenshots and the banner.
• Small refactors to command handling and stricter error handling for Lavalink reconnects.
• Prepare a short demo video for the Flavortown page and the upcoming YouTube source release.

Notes:
Hackatime tracking is active (verified heartbeats). Will post short updates as I progress.