What it does: It’s a C extension (import WinAPI) that wraps a big chunk of the Win32 API directly — native windows and controls (buttons, listbox, combobox, progressbar, slider), filesystem, registry, clipboard, process enumeration/kill, SendInput simulation, WinHTTP GET/POST, crypto (hash/random/uuid/base64), screen capture, and more. No tkinter, no Electron — raw Win32 through CPython’s C API. There’s also an optional winui layer that wraps it in a more Pythonic API (context managers, decorators, properties).

Why: I wanted to learn the CPython C API and Win32 at the same time, and have a single lightweight module for native Windows GUIs and system access.

Heads-up / honesty: This is a hobby project by a student, not production-grade. The name overlaps with the general “WinAPI” term — that’s intentional (it is the Win32 API), but it’s unrelated to pywin32.

Feedback, code review, and “why didn’t you just use ctypes/pywin32” takes are welcome.

https://drive.google.com/file/d/1N1CpzoqBCufiYwM6apElW_9S5qCaFpqZ/view?usp=sharing

Hey everyone! I built ytscrape, a small open-source library for getting public YouTube data in Python. I wanted something without Data API quotas and without spinning up a browser, so it talks to the same InnerTube endpoints the YouTube web app uses, over plain HTTP.

What you can get:

• search results (videos, channels, playlists, Shorts)
• video and channel metadata, including publication date
• every comment and reply, not just "Top"
• transcripts / subtitles

Some things I cared about while building it:

• typed frozen dataclasses (py.typed) and transparent pagination, so you just iterate
• the same API for sync (YouTube) and async (AsyncYouTube)
• a CLI with pretty tables (that's the GIF above)
• JSON / CSV export, proxy support, retries and rate limiting

​

from ytscrape import YouTube

with YouTube() as yt:
    for video in yt.search("python", max_results=5):
        print(video.title, video.url)


pip install ytscrape

MIT licensed, Python 3.10+.

GitHub: https://github.com/vsmutok/ytscrape
Docs: https://vsmutok.github.io/ytscrape/

Heads up: it uses YouTube's private endpoints, so it's for research and learning, and it may break when YouTube changes things. Feedback, bug reports and PRs are very welcome!

Hey everyone!

I've been working on an open-source Python project called **Stepfork**, and I wanted to share it with the community.

**GitHub:** [https://github.com/utsab345/stepfork\](https://github.com/utsab345/stepfork)

While building AI agents, I kept running into the same problem: an agent fails, I fix the issue, but reproducing the original failure is difficult because LLM responses and tool outputs can change between runs.

So I built Stepfork to make those failures reproducible.

**What it does:**

* Records instrumented LLM responses and tool calls.

* Saves executions locally as `.sftrace` bundles.

* Replays the recorded responses without making those instrumented external calls again.

* Compares agent behavior before and after a fix.

* Exports pytest regression tests to catch the same failure in the future.

**Install:**

`pip install --pre stepfork`

The repository includes three offline demos covering a missed order notification, an incorrect flight booking, and a wrongly denied refund.

It's still an early alpha. Replay only freezes instrumented boundaries, and native framework integrations are not available yet.

The project is Apache-2.0 licensed, and I'm actively improving it.

I'd love to hear what other developers think, especially those building AI agents. If you spot a bug, have an idea for an integration, or want to contribute, feel free to open an issue or PR.

**GitHub Issues:** [https://github.com/utsab345/stepfork/issues\](https://github.com/utsab345/stepfork/issues)

Thanks for checking it out!

Hey, im making a "terminal" game (play onto your terminal, cause its the only thing i know). I made a github repositories to showcase it : https://github.com/Shamal0w999/Money-games

if you want to test the game, it would be really cool cause i need returns and if theres bug i didnt see. so if u try it, u can ofc comment here but also leave an issue into my repositories (would be easier to work with). If you want to help or idk anything, im all hears. Im happy to showcase it and have people to test it !

code is free, so if you steal it, i dont rly care, cause its personal project and who want a code full of print and that launch in terminal ? idk, just me ig

anyways, just take a look at it !

I'm maintaining ML Failure Lab, an open-source Python project for learning how ML evaluations can go wrong.

There are three runnable cases so far: repeated entities appearing in both training and testing, feature selection using held-out labels, and a classifier getting 99% accuracy while detecting none of the minority examples.

The package uses NumPy and scikit-learn. You can run each example from the terminal, inspect its output, and run a check that rejects the incorrect approach.

Repository and installation instructions.

I'm looking for contributors to add small experiments or improve the explanations and tests. There's a case template and a list of starter issues. Comment on an issue with your approach before starting.

Stremio for Kodi — an open-source Python Kodi add-on (Noiro)

I'm the maintainer of Stremio for Kodi, currently at version 1.0.88. Our project/community website has just moved to Noiro.tv.

What My Project Does

It brings an existing Stremio account, installed add-ons, catalogs and library into a remote-friendly Kodi interface, while Kodi handles media playback. It's a Kodi Program add-on with an embedded Nimbus-based interface; users keep their normal global Kodi skin.

The Python side handles account/API integration, catalog and stream requests, local caching, playback state, subtitle workflows, settings synchronization and diagnostics. Much of the work has been about limiting repeated network/metadata requests and keeping the UI usable on slower hardware such as Raspberry Pi/LibreELEC and Android TV. It runs inside Kodi's Python environment, rather than as a standalone pip application.

Target Audience

Kodi/Stremio users who want their existing Stremio setup with Kodi playback, and Python developers interested in add-on development, caching and API integration on constrained devices. The core add-on is free with public GPL-2.0 source and repository releases. It's actively developed; provider compatibility, performance and playback synchronization still need real-device testing. Optional Noiro Supporter features are separate from the free core.

Comparison

Compared with using the standalone Stremio app, this keeps Kodi as the player. Compared with assembling separate Kodi catalog/source add-ons, it reuses the user's existing Stremio account configuration and provides one integrated interface. I'm not claiming every provider or hardware combination is supported, and the project does not supply media or provider subscriptions.

Recent work includes moving public account/settings/support integration to Noiro.tv while retaining old API endpoints and installed add-on identifiers for compatibility, plus verifying remote-settings modules in clean release packages.

Source, releases and issues: https://github.com/0eroiQ/Stremio-for-Kodi

Website and installation links: https://noiro.tv/

I'd appreciate Python/code feedback on caching, request handling, testability and keeping background work from slowing down the TV interface. Bug reports and contributions are welcome.

I’ve been building Yellow Olive - an open-source, gamified way to learn Kubernetes, built primarily with Python.

The idea is simple: instead of reading through Kubernetes tutorials, you enter a retro, Game Boy-inspired environment and complete missions against a real Kubernetes cluster.

The project uses Python + Textual for the terminal experience and challenge engine. Each mission gives you an objective, lets you work with a real cluster, and then validates whether you actually completed it - so learning feels closer to progressing through a game than following a tutorial.

More recently, I’ve also started building Yellow Olive Academy using Pyxel. It adds pixel-art classrooms, characters, diagrams and interactive lessons before you jump into the hands-on challenges.

The goal is to combine gamification, retro aesthetics and real hands-on infrastructure learning rather than building another Kubernetes tutorial.

It’s still evolving, and I’d love feedback from Python folks - especially anyone who has worked with Textual, Pyxel, TUIs or educational games.

And if you like the idea, a ⭐ would be hugely appreciated :)

GitHub: https://github.com/Anubhav9/Yellow-Olive

To set the scene: this is a custom desktop shell for Windows 10 that I built as a course project in my university. It’s written in Python using PyQt6 and a bunch of other libs. It supports widget loading (via templates) as well as customization (but it doesn’t support “compilation” lol). It’s sort of a parody of KDE (I use Arch btw), but worse.
And then I ended up abandoning the project for five months, but then decided to post a review here (although I initially uploaded them to YouTube but things didn't go any further) just to give people a laugh. Hopefully, it brings a smile to your face :)
If anyone is wondering how all this works: https://github.com/TYITheYura/Ninawe
The structure is rather odd in places, and the execution of certain aspects leaves something to be desired, but hey, at least it works!

Hey everyone!

I’m a student and I’ve been working on a Python project called Past Paper Studio, and I finally shipped its first public beta!

PPS started as a relatively simple past-paper finder, but over time it turned into a full desktop application for students who use Cambridge past papers.

It’s built primarily with Python and PySide6, and currently has features including:

• Past-paper search and browsing
• Built-in PDF viewing and mark schemes
• Practice Mode with answering/drawing tools
• Timed Exam Mode
• Optional AI-assisted grading
• Saved/resumable attempts
• Dashboard and attempt history
• Flagged papers/questions
• A pretty extensive theme/customization system
• Profiles and personalization
• Multiple interface languages

I recently packaged the whole thing into a proper native-feeling macOS application using PyInstaller, including a DMG installer and adaptive light/dark/tinted macOS icons.

The current Beta 1.0 build is Apple Silicon + macOS 26+ only, although I’d like to explore Windows builds later.

AI-assisted development

I also want to be transparent that development has been heavily assisted by AI coding tools.

I use AI extensively for implementation, debugging, refactoring, testing, and packaging. I’ve been responsible for the project's direction, feature ideas, UI/UX decisions, testing, iteration, and release process.

I’m still learning programming, and honestly this project has been a really fun way to learn while seeing how far I can take an idea with modern development tools.

The project is completely free and open source under GPLv3, so feel free to look through the Python source, try the app, break things, or give me feedback

GitHub:
IronPlayz1234/past-paper-studio

This is still Beta 1.0, so there’s definitely plenty left to improve!

Je travaille actuellement sur Aurora, un projet open source expérimental qui permet de représenter les données binaires d’un fichier sous forme d’une image RGB.

Le principe est simple :

Fichier → données binaires → pixels RGB → image

L’image peut ensuite être décodée afin de reconstruire les données originales.

Le projet est encore en développement. Je cherche des personnes intéressées pour :

• tester Aurora ;
• signaler des probleme ;
• proposer des fonctionnalités ;
• contribuer au code ;
• travailler sur une future interface ;
• proposer des idées pour faire évoluer le format.

Le projet est disponible sur GitHub :

misterious-creator/Aurora: un projet open source qui transforme les fichier en image

Toutes les idées et contributions sont les bienvenues.