Second devlog!

Worked on analyze.py which for now has 5 functions as the core of the project:

get_clean_lap which filters out sc, vsc laps, track limits and such
get_race_pace calculates the average race pace per stint
get_head_to_head combines 2 drivers’ laps into one table for comparison get_consistency_score uses standard deviation to measure the consistency
get_h2h_summary compares 2 drivers’ pace and tells which one was faster

• I’ve also started working on charts.py to set up the dark F1 color theme and pulled the official team colors from the session data.
• I tested everything in the terminal, VER vs LEC in Australia 2023 showed that Verstappen’s pace was 1.667 seconds per laps faster on average.

• This here is Max Verstappen’s race pace in Mexico, 2024:

Day 1 of working on PitWall (temporary name)

As an f1 fan and motosports fan in general, I wanted
to create something that I’m going to use myself pretty often and work with data that genuinely interests me which is why I’m creating PitWall, a website that analyses data using FastF1, an open source F1 data library. The main idea is to pull real F1 data and let people analyze race pace, quali laps, driver mistakes, simulate alternate race strategies. I’m also going to be using NASA atmospheric data to correlate weather conditions with lap time performance.

I started off by setting up my project structure in VS Code and install all the necessary libraries then, I wrote fetch.py which is a file from where I pull the data itself. Although, I faced an error on the way, a NotADirectoryError because FastF1 needed a cache folder that didn’t exist yet, fixed that by creating the folder manually. In the end I got it to work

The screenshot shows Verstappen’s first 5 laps from the 2023 Monaco GP

Shipping day!

Spent the last couple of days on everything around the code, which turned out to be way more work than I expected. Setting up git properly, fixing merge conflicts, getting PyPI to accept the upload, writing a .gitignore, creating a release tag. None of this is hard individually but it’s a lot of steps and each one has its own way of going wrong.
Also fixed two real bugs I hadn’t noticed: the tool would crash on non-ASCII characters like emoji, and nothing stopped you from saving the output as a .jpg (which would silently destroy the hidden data since JPEG is lossy). Both are one-liners to fix but they matter.
The project is now on PyPI at pip install steganohide, fully open source, with a proper README and release. It actually works and anyone can try it.

Devlog 3 — the decoder!

This one took more thinking than I expected. The decoder has to follow the exact same path as the encoder: same starting corner, same row-by-row order, otherwise it reads the wrong pixels and gets messy. The trickiest part was the stop signal logic. The decoder reads Red values one by one and asks “is this a 0?” at every pixel. If yes, stop and convert everything collected so far back to text. If no, keep going. Sounds simple but getting the edge cases right (what if the image has no message at all? what if it hits the end without finding a stop?) took a few tries.
When I finally ran encode → decode end to end and saw my message come back perfectly that was a relief.

Devlog 2!

Ran into my first real problem today, the SimpleImage library I started with wasn’t giving me direct pixel access the way I needed. Switched to Pillow and it made things a lot easier. getpixel() and putpixel() are what I needed.
Writing the encoder felt satisfying. You loop through every pixel, overwrite the Red channel with your character’s ASCII value, move to the next pixel, repeat. It sounds almost too simple but it works and the encoded image looks identical to the original.
Added a safety check too: if your message is longer than the image has pixels, it’ll tell you instead of crashing silently.

First devlog!

I’ve been wanting to build something that feels like actual secret agent stuff, and steganography caught my eye, hiding messages inside images that look completely normal. Nobody would ever know.
Getting started was harder than I expected. I didn’t know how pixel data actually worked at first, I just knew images were made of pixels. Turns out every pixel has three numbers (R, G, B) and ASCII characters are also just numbers, so you can literally swap one for the other. That clicked for me and I got excited.
Built the two core helper functions today: message_to_numbers which converts text to ASCII values, and numbers_to_message which does the reverse. The stop signal (0) idea came from wondering “how does the decoder know when to stop?” you need a flag at the end, like a period at the end of a sentence.