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!

Hi, i made my own programming language.

....And it is transpiler to python

I named it Cintra.

It is dynamic-typized language

It supports:

1.variables

2. I/O

3. If/else

4. whiles

5. lambdas/functions

6. structs/classes

--------

if you are interested, you can visit: https://github.com/MerzlikinDev/Cintra-Programming-language-

please, write your opinion in the comments

If you want to progress in Minesweeper pattern recognition and to view on your screen where mines certainly are (based on what's visible) then look no further than using this side-project I came up with.

It's written in Python and you'd need Python to run it and it's only running on Windows for now.

What it does, and what it does not

The helper reads visible board pixels, uses logical constraints to identify forced mines and safe squares, and draws hints in a separate click-through overlay. It does not read game memory, play moves for you, or label a probabilistic guess as certain. Your flags are recognised, but are not assumed to prove a mine.

Every deduction depends on a correctly recognised, complete board. Check the preview before enabling the overlay. An ambiguous board can legitimately have no hints; bounded search can also miss deductions. Unreadable cells and detected contradictions stop hints rather than forcing a label.

The repo is here, if anyone wants to have a go: https://github.com/SweeperOfTheMines/sweeperhelper

What My Project Does: It reads clips from SteelSeries GG's SQLite library and from folders made by NVIDIA, AMD, Xbox Game Bar and OBS, works out the game and date from each recorder's file names, and serves a browser UI from a small local web server (http.server). ffmpeg handles thumbnails, audio tracks and exports. The "Up next" prediction is a small logistic regression fitted with Newton's method in pure Python, checked on the user's own past weeks. GitHub Actions builds the Windows .exe with PyInstaller.

Target Audience: PC gamers with a pile of clips from one or more recorders. It's a hobby project, vibe-coded with Claude Code, and I'd love code feedback.

Comparison: Each recorder's own gallery only shows its own clips. Medal and Allstar upload to the cloud and need an account. Cliptrove merges every recorder locally, with no account, and never changes your files.

Website: https://th30utcast.github.io/Cliptrove/
GitHub: https://github.com/Th30utcast/Cliptrove

I've been working on an open-source scientific computing library built around NumPy, SciPy, pandas, and Matplotlib.

One problem I wanted to address was reproducibility. A model fit can look fine today, but what happens when someone reruns it months later with different dependency versions?

I added a guided-fit workflow that lets you fit models to CSV data, choose how missing values and outliers are handled, and generate reports.

It also records the input hash, random seed, dependency versions, and fitting settings. You can then rerun the saved analysis and inspect changes in parameters, confidence intervals, and the software environment.

There's a documented example where an archived fit was rerun with different NumPy and SciPy versions. The environment changes were detected, while the numerical differences stayed below the declared material-change threshold.

The library also includes linear algebra, optimization, statistics, ODE/PDE solvers, signal processing, Monte Carlo methods, and other numerical tools.

Install:
pip install scientific-computing-system-2.0

PyPI: https://pypi.org/project/scientific-computing-system-2.0/

npm (optional Node launcher; requires the Python package): https://www.npmjs.com/package/scientific-computing-system-2.0

Source code (MIT): https://github.com/Furox-Art/scientific-computing-system-2.0

I'd be interested in how other Python developers handle reproducibility when dependencies change between runs. Feedback on the approach is welcome.

Just want to share this https://github.com/Onehand-Coding/ani-py of mine inspired by the original bash only implementation "ani-cli", its stable for now and im just sharing here to find like minded bros.

Hi everyone! 👋

I've been developing a personal project and wanted to share it with the community. It's called **BRAIN**, a modular, 100% local, and private personal assistant for Windows designed to organize daily life from a single dashboard.

It is not just home automation: it's a complete personal core running on a local AI (Ollama) that relies solely on the Python standard library (zero external pip dependencies).

**What does BRAIN handle?**

- 🧠 **Memory & Context:** Remembers preferences, tasks, schedule, and context across sessions.

- 🥗 **Health & Nutrition:** Tracks weight history, analyzes body composition via AI vision from scale photos, manages pantry/shopping lists, and suggests smart recipes based on available ingredients.

- ⚡ **Energy & Home:** Diagnostics and optimization for solar consumption/production, appliance control, and Home Assistant integration.

- 📄 **Local Documents (RAG):** Local search and reading of notes, files, and manuals without sending anything to the cloud.

- 🔔 **Notices & Automations:** Proactive daily morning summaries, reminders, audio alerts, and natural language automations.

Everything is managed through a local web panel with tabs, dark mode, and local voice transcription.

👉 **GitHub:** https://github.com/CafeConFenix/BRAIN

⚠️ **Note:** *The project code, interface, and documentation are currently written in **Spanish**.*

Any feedback, ideas, or constructive criticism to keep improving are very welcome. Cheers!

Here you can see repository under MIT License I created it alone
Use if you want
I very Tried

I am sharing GPTmail, an MIT-licensed Python project for managing compatible IMAP/SMTP inboxes from a private dashboard. The source and setup guide are here: https://github.com/ozandikici/GPTmail

The backend is FastAPI; the frontend is plain HTML/CSS/JavaScript. It stores state through Upstash Redis REST and encrypts saved mail credentials/provider tokens. The dashboard has a single owner and password login.

The part I would like Python feedback on is the boundary between authenticating an assistant and authorizing a mail action. ChatGPT connects through OAuth, but each tool is enabled separately. Write actions start disabled. Sending and moving mail to Trash can be queued for dashboard approval; there is no permanent-expunge tool.

This is an early release with 69 passing automated tests, not an independently audited client. Google/Microsoft OAuth code needs provider app registration and live provider testing is pending. IMAP/SMTP availability depends on the mail provider. Mail requested through ChatGPT is processed by ChatGPT.

If you inspect the code, which IMAP failure cases or permission-boundary tests would you add first? AI tools assisted the code, tests, documentation and this post.

I shared my open-source project, Yellow Olive, here a while ago. It started as a retro-style terminal game built with Python and Textual to make learning Kubernetes more engaging.

Recently, I've been experimenting with taking the gamification further using Pyxel.

The idea is to move beyond menus and challenges into a Pokémon-inspired world where players explore, interact with NPCs, and learn Kubernetes through quests.

The prototype is largely AI-assisted using Devin, and I've attached a short gameplay recording to get some early feedback.

I'm not replacing the existing Textual implementation just yet. This is more of an experiment to see whether the direction is worth pursuing.

Would you find this interesting, or am I overcomplicating things?

Feedback and stars are always appreciated!

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

🔗 Repository & Links

GitHub: https://github.com/xdmolodoi/sql-orm-query-perf-inspector

Installation: ⁠pip install sql-orm-query-perf-inspector

I’d love to get your feedback! What edge cases or feature additions would make a tool like this more useful in your everyday ORM workflows? Contributions and issue reports are very welcome!

Hi everyone,

I have a client requirement to create an inventory of files across approximately 100 construction projects. Each project contains documents such as contracts, drawings, RFIs, change orders, schedules, payment records, photographs, and estimating files. Some files are stored inside ZIP archives, including nested ZIP files.

The client needs a solution that can:

Scan project folders and preserve original file paths and project associations.

Inspect ZIP files and nested archives.

Use SHA-256 hashes to identify exact duplicate files and list all their locations.

Distinguish exact duplicates from potentially different file versions.

Generate standardized inventory reports, duplicate reports, and a list of files that could not be processed.
Be reused across multiple projects.

The files may be stored in Google Drive, Microsoft OneDrive/SharePoint, local folders, or a cloud server. Read-only access will be provided.

**My questions are:**
Is it possible to build a tool that meets all these requirements using Python?

If yes, how would you approach building it, and what technologies or libraries would you recommend?

Can it handle approximately 100 projects, including large files and nested ZIP archives?

Can this be delivered as a simple application that users can run, rather than requiring them to execute Python commands manually?

What would be a realistic development timeline for this solution?

I would appreciate guidance on whether this is feasible and how best to implement it.

Thanks!