Background
In this project I started building a self-hosted homelab control panel designedto manage and monitor a local machine or server from a single web interface.
The main idea is to combine multiple homelab tools into one simple dashboardthat runs locally and is easy to extend.

What I’ve worked on so far:
Set up the base FastAPI backend
Structured the project into separate modules for monitoring, Dockermanagement, file handling, and database toolsBuilt a basic web dashboard using HTML, CSS, and JavaScript
Planned integration of system metrics using psutilDesigned the structure for Docker container control and file accessThe panel is meant to act like a lightweight homelab management system whereyou can:

• monitor system performancemanage
• Docker container
• shandle files on the server
  run simple database queries

The main challenge was designing a structure that stays modular but still simple enough to build within a limited timeframe. I also had to thinkcarefully about how system-level features should be exposed safely through a web interface.
Another useful aspect is that this mission came at a good time, since I wasalready planning to build something in this direction, so I was able to alignmy work with it.

A simple “link in bio” page built with HTML and CSS.

Build Time
This project was created in approximately 15 minutes as a quick test to see how fast I can make a simple static website.

Features
Profile section with avatarName and short descriptionSocial media linksClean responsive layout
Hover effects on links

Homelab Control Panel (Work in progress)
In this project I started building a self-hosted homelab control panel designed to manage and monitor a local machine or server from a single web interface.
The main idea is to combine multiple homelab tools into one simple dashboard that runs locally and is easy to extend.
What I’ve worked on so far:

Set up the base FastAPI backend

Structured the project into separate modules for monitoring, Docker management, file handling, and database tools

Built a basic web dashboard using HTML, CSS, and JavaScript

Planned integration of system metrics using psutil

Designed the structure for Docker container control and file access

Main idea:
The panel is meant to act like a lightweight homelab management system where you can:

monitor system performance

manage Docker containers

handle files on the server

run simple database queries

Challenges so far:
The main challenge was designing a structure that stays modular but still simple enough to build within a limited timeframe. I also had to think carefully about how system-level features should be exposed safely through a web interface.
Another useful aspect is that this mission came at a good time, since I was already planning to build something in this direction, so I was able to align my work with it.

Today I updated a large part of the website’s CSS to improve the design, layout, and responsiveness. I also added new features, fixed UI issues, and cleaned up the code to make future updates easier.

NANOS MULTI-TOOL v3.0A modular, terminal-based system administration and utility suite built with Python and the Rich library.FeaturesSystem Tools: Monitor CPU, RAM, disk usage, and track top memory-consuming processes.Network Tools: Ping hosts, perform DNS lookups, scan common ports, and retrieve public IP.File Tools: Analyze file sizes, find exact duplicate files via SHA-256 chunking, and read text files.Security Tools: Generate cryptographically secure passwords and create SHA-256 hashes. Developer Tools: Beautify JSON, test HTTP GET requests, and encode/decode Base64 strings.Live Dashboard: Real-time overview of local/UTC time, OS info, and hardware stats.

Developer Log - TerminalOS

Project Overview

TerminalOS is an interactive CLI simulation designed to mimic a basic Unix-like environment inside a standard console. The development focused heavily on shifting from unstructured procedural code to a robust object-oriented architecture, improving data persistence stability, and refining user interaction.

What Was Achieved

OOP Architecture Conversion

The entire codebase was refactored into a centralized TerminalOS class. Instead of passing state manually through disparate functions or relying on unsafe global variables, the application now encapsulates its configuration, user profiles, and runtime loops inside dedicated class properties (self.state, self.user, self.running).

Scalable Menu Navigation (Dictionary Dispatch)

To avoid messy, nested if/elif/else blocks inside the main user loop, a dictionary dispatch pattern was implemented in the desktop interface. By mapping user selection keys directly to object methods, the code remains clean, readable, and easy to extend with new features in the future.

Defensive Error Handling and State Recovery

Recognizing that sudden terminal closures frequently cause JSON files to corrupt, the state loading mechanism was hardened. The system explicitly traps json.JSONDecodeError and ValueError during startup. If a bad file is detected, it logs a warning cleanly to sys.stderr and drops back to a safe default payload, preventing hard system crashes.

Input Sanitization and Quality-of-Life Patches

Local validation testing revealed edge-case bugs, such as accidental whitespace entry skipping password validation. This was patched by applying .strip() to user string inputs and adding fallbacks for empty names. Additionally, the Matrix rain visual effect was updated with a customized mixed-ASCII charset to move away from overused open-source tropes.

Technical Debt & Next Steps

• The hardware diagnostics panel currently uses static, hardcoded placeholder data. This needs to be converted to dynamic readouts using standard library utilities to keep the project dependency-free.

My very first webos

I tried to build a simple Python IDE for kids using CustomTkinter. I wanted a clean layout with a code editor, file explorer, and a run button that doesn’t freeze the app. I also wanted to translate scary Python errors into simple English and add a lesson system with badges.I managed to do it by using the threading module to run code in the background. I used standard tkinter Text widgets for the code editor so I could add syntax highlighting and line numbers. For the errors, I wrote a helper script that uses regex to find common mistakes and prints friendly hints. The lessons and badges are stored in a local JSON file.I will modify it in the future. Right now the input function doesn’t work because of the background thread, so I want to fix that. I also plan to add more templates and maybe drag and drop file support.

How I spent 3 hours making a clicker game and lost my mind
I sat down yesterday thinking, “A basic Cookie Clicker clone will take me 1 hour top.” Three hours later, I have 15 buildings, a full prestige system with a separate diamond shop, and a main JavaScript file named scrpit.js that I refuse to rename because I’ve accepted my typo as a feature.
What happened in those 3 hours?
Hour 1: Making it look shiny.
Before writing any actual game logic, I spent way too long tweaking CSS. I added glassmorphism to the menus, gave the main button a fake 3D shadow that squishes when you click it, and added a neon glow that pulses behind it. The game didn’t work yet, but clicking that empty button felt good.
Hour 2: Feature creep.
I started with 5 buildings, then thought, “let’s add synergies where buying 10 of the same building doubles its output.” Then I added Golden Cookies that spawn randomly to give you a x777 click frenzy (yes i got it from Cookie Clicker).
Hour 3: The Prestige System.
I decided to add a reset mechanic. Once you hit 1 million points, you can reset for Diamonds. But instead of a boring flat multiplier, I built a whole separate Diamond Shop where you spend your hard-earned gems on permanent upgrades that carry over into your next run. Getting the localStorage save function to remember both your normal run AND your permanent prestige upgrades was… chaotic.

The Code
It is absolute spaghetti, but it works.I used innerHTML += to render the building shop because I was too lazy to do proper DOM manipulation. I wrote manual for loops to search through arrays instead of using .find() because my brain was fried.
The only “clean” thing I did was implement a proper requestAnimationFrame game loop with Delta Time so your passive income doesn’t break if you minimize the browser tab. The game is completely unbalanced and the numbers get stupidly huge, but it was a fun 3 hours. Check out the repo if you want to look at scrpit.js and judge my variable names. Let me know what CPS you can hit!