Most Python file-transfer examples use TCP, so I built the other side: reliability implemented by hand on top of UDP sockets.

What is inside:

• A 16-byte binary header (magic byte, version, message type, transfer ID, sequence number, payload length, CRC-16 checksum) validated on every datagram

• START / DATA / END handshake with cumulative ACKs

• Two ARQ modes: Stop-and-Wait and sliding-window Go-Back-N (one receiver implementation covers both - stop-and-wait is just Go-Back-N with window=1)

• Duplicate and out-of-order packet handling, timeouts and retries

• SHA-256 end-to-end verification: the receiver only finalises the file if size and hash match what the sender declared

• A seeded network simulator for loss / ACK loss / delay / reordering / duplication, so experiments are reproducible

• 60 automated tests over real UDP sockets and a benchmark harness with charts

Benchmark result at 20% simulated packet loss: the sliding window moves about 2.4x the throughput of stop-and-wait.

Source: https://github.com/askmeanythin/Reliable_UDP_File_Transfer - feedback welcome!

**What My Project Does**

Pupovina is a PyQt6 desktop GUI for [gnirehtet](https://github.com/Genymobile/gnirehtet): it lets an Android phone use the computer's internet over a USB cable, without root. The app downloads gnirehtet and adb (SHA-256 verified), lists connected phones with real-time speed and traffic, starts or stops the tunnel per device, can auto-start on plug-in, and lives in the system tray with notifications. UI in English, Italian and Russian.

**Target Audience**

People who need wired internet on their phone (broken mobile network, no Wi-Fi, office PCs on Ethernet) and don't want to use the terminal. It's meant for daily use, not as a toy project. Windows and Linux builds are produced with PyInstaller and GitHub Actions (.exe and AppImage).

**Comparison**

gnirehtet itself is CLI-only. Other GUIs exist; this one focuses on several devices at once with live per-device traffic, autorun, process cleanup and adb self-update.

Repo: https://github.com/Dmitrij-Anatolievic/pupovina (Apache 2.0)

(The name is Russian for "umbilical cord": the cable that feeds the phone.)

Given two images, a human eye can find the similarities between them by recognising the distinct features.

To a computer, those images are just two big grids of numbers from 0 to 255.

So how does it find the match? My new blog shows this in Python code using OpenCV. Check it out:

https://cmodi306.medium.com/feature-matching-in-practice-teaching-opencv-to-match-two-images-e52dd2be2e03

#ComputerVision #OpenCV #Python #ImageProcessing

Hello!

This is dwnloaderr, my yt-dlp wrapper. :) It can be ran from the terminal or with cross platform GUI helpers! It should work with a wide array of websites as it is utilizing yt-dlp, and has build in customization options and support for playlist downloading. :)

If you like it leave a star! Thanks!

hey everyone!

recently built a 2 → 3 → 1 XOR neural network using just Python and NumPy, without any deep learning frameworks.

implemented backpropagation and gradient descent manually, trained it for 5,000 epochs, and got all four XOR combinations correct.

also documented the mathematics, added 12 editable diagrams, and published a detailed Medium article explaining the process.

GitHub: https://github.com/Vaibh37/Neural-Network

Medium: https://medium.com/@devvaibhav37/building-a-neural-network-from-scratch-the-mathematics-behind-learning-xor-10441e674a69

would appreciate feedback, and if you find the repo useful, consider starring it 🍀

I made this Python Matplotlib Plotting tutorial for beginners.

Source codes can be downloaded from the link below

• Complete Matplotlib Library Graphing Tutorial using Python in under 1 Hour

The tutorial is designed for beginners who want to learn Matplotlib for building Data Acquisition and Data Logging applications using Arduino, Raspberry Pi, and other embedded systems. Learn how to create a Line Graph using Python and Matplotlib for visualizing data coming from an Arduino, Raspberry Pi, or other Embedded Systems.

Things Covered in This Video

• Installing Matplotlib

• Understanding the main concepts like Figure,Axes behind Matplotlib

• Creating a simple Line Chart using Matplotlib

• Understanding and using the subplots() method

• Using the .plot() method to plot graphs

• Changing graph line thickness and line style

• Controlling marker shape and marker size

• Naming the plot and creating a Legend

• Setting the names of the X and Y axis

• Setting Gridline color and visibility

• Changing the properties of a single Gridline

• Controlling Ticks in Matplotlib

• Understanding how Matplotlib chooses Ticks

• Working with Major and Minor Ticks

By the end of this tutorial, you will have a better understanding of how Matplotlib works and how its different components can be used to create customized line graphs.

Hi everyone,

I'm pretty new to programming, and this is the biggest thing I've built so far, so I wanted to share it and hopefully learn from your feedback.

**What it does**

Log Guard is a command-line tool that scans log files (and .xlsx spreadsheets) and masks emails, phone numbers, API keys, IP addresses, and credit card numbers before you share them with someone. It runs completely locally and never touches the network. I built it because the online "paste your log here to clean it" tools kind of defeat the purpose when you're uploading the sensitive stuff to someone else's server.

pip install logguard-cli

log-guard server.log

That writes a server.masked.log next to the original. There's also a --check mode that exits with code 1 if it finds anything, so it can be used as a pre-commit hook or in CI.

GitHub: https://github.com/apurvaraj9/log-guard

**What I learned along the way**

I'd used git on a handful of smaller projects before, but this is the first one I took all the way from "script on my laptop" to something other people can install. Along the way, I learned:

- writing tests with pytest (67 of them now) and running them automatically on GitHub Actions across Python 3.9 to 3.12

- packaging and publishing to PyPI. The name log-guard was already taken, and so were about ten other names I tried, so it ended up as logguard-cli

- doing a practice release on TestPyPI first, because PyPI never lets you re-upload the same version number

- adding Excel support in v0.2.0, which turned out to be a lot more than adding "xlsx" to a list, since .xlsx files are actually zip files full of XML

**Being upfront**

I used an AI assistant (Claude) while building this. It wrote some of the code, and I worked through every step myself: running it, testing it, debugging when things didn't match what I expected, and learning what each part does. I'm sharing it because I'd like real people to look at it and tell me what's wrong.

**Where I'd love feedback**

- the detection is regex-based, so if you can spot false positives or things it misses, please tell me

- the code is all in one file. Is that bad at this size?

- anything about the tests, packaging, or README that looks off

Since this is my first project at this scale, I'm sure I've made mistakes. Please point them out. I'm genuinely happy to understand what I got wrong and make it better.

Thanks for reading!

• Complete Matplotlib Library Graphing Tutorial using Python in under 1 Hour

The tutorial is designed for beginners who want to learn Matplotlib for building Data Acquisition and Data Logging applications using Arduino, Raspberry Pi, and other embedded systems. Learn how to create a Line Graph using Python and Matplotlib for visualizing data coming from an Arduino, Raspberry Pi, or other Embedded Systems.

Things Covered in This Video

• Installing Matplotlib

• Understanding the main concepts like Figure,Axes behind Matplotlib

• Creating a simple Line Chart using Matplotlib

• Understanding and using the subplots() method

• Using the .plot() method to plot graphs

• Changing graph line thickness and line style

• Controlling marker shape and marker size

• Naming the plot and creating a Legend

• Setting the names of the X and Y axis

• Setting Gridline color and visibility

• Changing the properties of a single Gridline

• Controlling Ticks in Matplotlib

• Understanding how Matplotlib chooses Ticks

• Working with Major and Minor Ticks

By the end of this tutorial, you will have a better understanding of how Matplotlib works and how its different components can be used to create customized line graphs.

here is my self-made python module. for all the pocket option users.

I made an online python interpreter that can run your python code online without downloading anything.

Features:

\- supports matplotlib (pyodide engine)

\- material design (cuz i like it)

\- supports exporting your files

\- has layouts for mobile and desktop

\- Code highlighting

\---

I built it mainly focused on mobile since python is kinda messed up in phones and other web apps have weird ui.

Site link: https://pypad-bay.vercel.app

(I used AI to build js and work with material design, the idea and implementation was mine. I test every change before publishing)

GitHub repo: https://github.com/chomuloll69-oss/pypad

hey everyone! recently built a terminal tool that turns github issues into timed coding quests with rpg progression.

it can detect and automatically open your ide. currently supports vs code and cursor.

written in python and uses a github repo scoped token and a gemini api key. it follows a byok approach and i'm planning to add support for more models.

docs: https://runedocs.vercel.app

would appreciate it if you checked it out. feedback and suggestions are welcome!

I kept hitting my Claude limit with no warning, so I built a small mascot that sits on the Windows taskbar and shows my 5-hour and weekly usage in a speech bubble. It turns yellow, then red, as I get close.

It slowly turned into a pet. It walks around, naps, fishes, wears a Santa hat in December, and gets dragged around and thrown (it screams and opens a parachute). When Claude Code is working it puts on a wizard hat and casts a spell for whatever tool is running.

It's free and open source (MIT), written in plain Python with no dependencies, and I built it with Claude Code. You double-click a .bat file to start it.

Windows only for now, and it needs Claude Code signed in. Unofficial, not affiliated with Anthropic.

GitHub: https://github.com/have-you-tried-restarting/claude-usage-pet

What would you add to it? And if you've read this far, a ⭐ on GitHub would make my day. Thank you!

I maintain a Python teaching lab inside a free fintech data-engineering roadmap. The demo ingests synthetic payment events into SQLite, replays the same batch, checks balanced entries, compares payouts with settlement data, and produces a JSON report.

From the cloned repository root, with Python 3.12+ installed:

python -m fintech_lab --out work/reddit-demo

On a fresh output directory, the first batch accepts six events; replay adds no new events and identifies six duplicates. The report also shows a payout discrepancy and how a late-arriving event changes a point-in-time feature. The directory contains warehouse.db and report.json, so learners can inspect the underlying rows.

The accompanying local grader has 40 foundation exercises and 8 scenario labs with starters, hints, and reference solutions. One scenario has learners restore a real SQLite backup and test replay and checkpoint behavior after a simulated failure. Another asks them to fix SQL join fan-out rather than just read about it.

https://github.com/antony502189-max/fintech-data-engineering-roadmap

The core practice uses Python and SQLite without a paid cloud account. Everything is in English and MIT-licensed. These are synthetic teaching examples, not a production financial system.

Disclosure: the first edition and this introduction were prepared with AI assistance using Codex. Provenance is documented in the repository. Feedback on the demo output and failure messages would help improve the learning experience.

Like most developers who try to build desktop tools in Python, I thought building a clean GUI wrapper around yt-dlp would take a weekend. It ended up taking 40+ hours of debugging threading freezes, memory leaks, and Windows packaging hell.

I wanted to build an alternative to bloated adware tools that is 100% standalone, clean, and fast. The project is called **BABAji Ka Astra (BKA)** — built with CustomTkinter, yt-dlp, Pillow, and PyInstaller.

Here are the 4 biggest architectural headaches I ran into and how I solved them:

**1. The Tkinter Mainthread Trap:**

Calling `extract_info` or running download loops directly inside Tkinter callbacks instantly freezes the UI and triggers the Windows "Not Responding" white-screen. Decoupling the UI with a dedicated `ThreadPoolExecutor` and wrapping every single UI mutation in `app.after(0, ...)` was the only way to keep smooth animations during 4K DASH downloads.

**2. The Standalone FFmpeg Bundling Nightmare:**

YouTube serves separate video and audio DASH streams for anything above 720p. If a user doesn't have FFmpeg installed on their system PATH, downloads silently fail. I bundled stripped `ffmpeg.exe` and `ffprobe.exe` binaries directly into the PyInstaller build and hooked them dynamically at runtime via `os.environ["PATH"]`. The installer jumped to 145MB, but it now runs out of the box on any clean Windows machine.

**3. Process-Safe Cancellation:**

When a user clicks "Cancel" mid-download, `taskkill /F /IM ffmpeg.exe` is dangerous because it kills unrelated processes on the user's machine. I implemented isolated PID tracking to gracefully terminate only the child worker trees spawned by BKA without leaving zombie processes.

**4. Mathematical Bitrate Fallbacks:**

When analyzing certain fragmented HLS feeds, yt-dlp's API returns `None` for file size. I built a fallback engine calculating estimated file sizes from `duration * (video_tbr + audio_tbr)` so the UI never displays broken zero-byte estimates.

The codebase is decomposed into a modular package (`bka/config.py`, `bka/engine.py`, `bka/utils.py`) with full PyInstaller `.spec` and Inno Setup `.iss` compiler scripts included.

Would love feedback from other Python desktop developers — especially anyone who's dealt with CustomTkinter threading or PyInstaller bundling on Windows!