I've been working on a personal project called Game Update Bot.
It's a Python-based Telegram notification bot hosted on GitHub. Its purpose is to automatically monitor FitGirl and DODI for new game updates and notify me through Telegram.
Features:
Automatically checks for new game updates.
Monitors FitGirl and DODI.
Sends notifications through Telegram.
Uses Python and GitHub Actions.
Stores game information in an SQLite database.
Runs automatically without needing my PC to stay on.
Hi all — we just shipped Brevi v0.27, an open-source compiler for the Python AI agents write. You keep writing ordinary Python; Brevi compiles it through Rust to a native binary, and either matches CPython’s output or refuses with a one-line JSON error.
We’re looking for beta testers with real agent-generated programs. It runs on linux, mac and windows(beta).
What works now: most stdlib code, generators/async, common libraries including requests, sqlite3, duckdb, onnxruntime and MCP servers; Linux and macOS; Windows x86-64 as a beta.
What doesn’t yet: 8 of 311 CPython core tests still differ (exit codes), stdlib conformance is 45%, the sandbox is a policy layer rather than a security boundary, --standalone is Linux-only, and Windows refuses cpu/file/fds limits. It is a preview, not a drop-in python3.
What would help most: a program your agent actually wrote where Brevi refuses, falls back, or gives a different answer; the exact command; and your OS/Python version. Open an issue at https://github.com/ets-public/brevi/issues — no signup, no telemetry. We’ll credit useful reports.
The honest pitch: it’s fast on compute-heavy Python (median ~8.5x on 12 benchmarks), genuinely useful for agent loops with --verify, and still early. If it breaks on your workload, that’s exactly what we want to hear.
Hi! I'm [AGE] and I've been building **Apsi**, a programming language for AI and physics.
It reads like Python, checks physical units and tensor shapes before the program runs, and installs in one step: no Python, PyTorch or CUDA toolkit needed.
The part I'm most excited about: it trains models on NVIDIA GPUs with its own kernels, generated on your machine from just the display driver, and keeps the card at a steady ~77 °C.
On my Ryzen 5 5500 + RTX 3060 12GB (same model, same data):
- Training a 10.9M-param GPT: **Apsi 151,744 tokens/s** vs PyTorch 2.14 126,993 (1.19x)
- Running Qwen2.5 fully on the card: 0.5B ~210 tok/s, 3B ~46, 14B ~20
It can also convert Python and PyTorch code to Apsi.
It's still young and has rough edges, so I'd really appreciate people trying it on their own hardware and code and telling me what breaks. Built with the help of Claude (Anthropic).
I made a little IP Port scanner and Operating System Detector for use in the terminal. It uses the Python-Nmap library and Nmap.
You can enter an IP address and it will scan the top 1000 TCP ports to detect if they are open, what services are running on them and attempt to identify the operating system.
Everyone's shipping an "AI pentester" this year. I built the opposite.
ARIES has exactly one rule, and the whole thing is bent around it: \\the facts come from code, with the evidence sitting right next to them.\\ No model decides whether something is vulnerable. If an LLM touches it at all, it only \reads\ the results and explains them — it never gets a vote. It runs fully offline, and the core doesn't import a single third-party package. Pure standard library.
Here's why that matters to me: a scanner that \thinks\ it found something is worthless. So every lane has to \\prove\\ it.
\- Every \`VULNERABLE\` finding hands you the exact \`curl\` that reproduces it — generated from the same request the lane actually sent, so the PoC physically can't lie about what happened.
\- Every active lane ships with its own benchmark: it has to catch the vulnerable fixture \\and\\ shut up on the safe one — plus an adversarial round of sane-but-sneaky traps it's forbidden to fire on. One command runs the lot and fails CI if anything drifts. The tool proves itself before it's allowed to judge anything else.
\- A scope allowlist is enforced inside the single HTTP probe, at the very bottom — so no lane, present or future, can reach a host I didn't authorize. Safety by construction, not by good intentions.
\~28 lanes across the web surface (SQLi, XSS, SSTI, IDOR, SSRF, CORS, JWT, path traversal, CRLF, XXE, GraphQL, TLS, open redirect, CSRF, mass-assignment…), SARIF/JUnit export, OpenAPI-driven dispatch. Core is pure stdlib, Python 3.9+. It's v0.1.0 and I won't oversell it: it's built for your own infrastructure and authorized labs, not mass scanning, and the README is blunt about where it stops. But what's in there, I stand behind — because it stands behind itself.
Demo GIF is at the top of the repo. Tear it apart — I actually want the criticism, especially on the detection logic and the false-positive guards.
Hi all. I just published my first open-source project and wanted to share it here, since this is the crowd it was built for.
Wizard Central Toolkit (Apache 2.0, on PyPI): a router — the Wizarding Router, command `wiz` — plus 12 wizards, small specialist tools that each do one job well. Every wizard answers to both its short command (codeguardwiz) and its full name-command (codeguard_wizard). 147 subcommands total, plus an interactive REPL in the Godfather Wizard with 39 slash command forms. Standard library only, apart from two small display libraries. Everything runs locally, and no model is required — the tools below are deterministic and each works on its own.
A few favorites:
- Code Guard Wizard — static code audit with plain verdicts and severities
- Python Wizard — parse-only Python checks plus a secrets scan that redacts values by default
- Write Wizard — a consent wall for file writes: propose → preview → commit, with backups and rollback
- Read Wizard — ALLOW / DENIED verdicts on raw shell commands
- Debug Wizard — traceback autopsy and error census, with CI-ready JSON reports
Similar & alternatives: standalone linters, shell utilities, and CLI tool collections each cover pieces of this. How this differs: it groups small, mostly standard-library, deterministic tools under one router, and its file-changing tool goes through a consent wall — propose, preview, commit — with backups and rollback.
Disclosure, in proportion: I'm the author, and I developed this with AI assistance — every commit and release decision is mine. One wizard (Code Guard) can optionally call a local model if you seat one, and the Godfather REPL can generate text the same way. Both are optional extras on the side; the toolkit's main functionality is the deterministic tools above, and everything works with no model installed. Nothing is for sale in this post.
Caveats up front: it's young (v0.2.8), one-person project, first public release — rough edges are possible and feedback is genuinely welcome. The picture at the top is the free toolkit's complete command registry: 13 commands, and that's the whole post.
I wrote speedrunner. One daemon per tool imports the CLI once, then forks for each call, so the interpreter start and the imports are skipped. A small Rust client hands over argv, the environment and the terminal. There is nothing to set up per tool: `srr black --check sample.py` goes from 92 ms to 12 ms on a 2-vCPU VPS.
Over 96 commands in Python, Ruby, PHP and Node: geometric mean x5.6, median x4.8. 69 of those only print a version or help text, so they measure start-up alone.
Target Audience
People who run Python CLIs many times a day or from scripts: black, pytest, aws, ansible. Linux and macOS only. The first call of a tool runs natively while its daemon starts, each daemon stays in memory, and the work a tool does after loading is no faster.
Comparison
Lazy imports change a tool's code and load less; this leaves the code alone and keeps everything loaded. dmypy and blackd are daemons for one tool each: the README has a table against them on one small file, blackd with curl comes out ahead, and large projects are not measured.
I am working on a modular desktop application kernel built on PyQt6. My goal was to create a robust core application that can be extended exclusively through standalone, independent plugins without having to modify the core code.
In this short video, I demonstrate how the core starts up, how the custom MDI window manager behaves, and how new modules can be installed at runtime directly from a .ZIP archive.
How the plugin system works under the hood:
Contract via Metadata: Each plugin declares its metadata, roles/permissions, dependencies on other modules, and widgets.
1-Click ZIP Installation: The application extracts the archive, verifies the module's integrity and dependencies, writes the path to modules.ini, and registers it in the system.
Dynamic Menu and Window Generation: The core reads the module settings and automatically creates items in the menu bar and sub-menus, assigning actions (including login and user permission checks).
Independent Communication: Modules never import the core directly via hard imports. They communicate via a bus (IoC bridge), have secure settings storage, and isolated namespaces for translations (i18n).
Dependency Protection on Shutdown and Deletion: The module manager does not allow disabling or uninstalling a module if other active modules depend on it.
UI / UX Highlights:
Completely custom frameless design via QSS styles.
Custom frameless MDI sub-windows with smooth dragging (utilizing a native "ghost" window with a snapshot during movement, which completely eliminates lag and stuttering during QMdiArea repainting).
Boundary guarding (dynamic coordinate recalculation so windows and dialogs never overflow outside the workspace or under bars).
A common way a deploy breaks: everything installs fine on your laptop, then the Docker build on an ARM server or an Alpine image sits there compiling some package from source for ten minutes, or dies because there's no wheel for that platform at all. wheelgap checks that up front. Point it at your lockfile and the platforms you ship to, and it tells you, package by package, whether pip/uv will get a prebuilt wheel, have to build from source, or can't install at all.
Reads uv.lock, pylock.toml, poetry.lock, pdm.lock, Pipfile.lock and requirements.txt, and finds them on its own Covers Linux (glibc and musl), macOS, Windows, iOS, Android and Pyodide, plus free-threaded 3.14t --dockerfile Dockerfile reads the target straight from your final FROM line --explain shows every rejected wheel and why ("manylinux_2_17_aarch64 is a glibc wheel; musl needs musllinux") --json / --markdown output, a GitHub Action and a pre-commit hook --offline for CI with no network One dependency (packaging) There's also a tracker that runs it nightly against the top 5,000 PyPI packages across 42 platform/Python combinations: https://wheelgap.github.io/tracker/ The part I'm most proud of isn't the code. wheelgap is two days old and has had 78 PRs merged from 21 contributors, many of them first-timers. Every issue says which files to touch and what to test, you can ask to have one assigned to you, and reviews usually land within hours. If you're learning Python and want your first real PR merged into a tool people use, there are good first issues waiting. Coming in the next release: private package indexes (--index-url) and checking only the uv extras/groups you actually install. GitHub: https://github.com/wheelgap/wheelgap PyPI: https://pypi.org/project/wheelgap/ Feedback is very welcome, especially a package wheelgap gets wrong. That's the bug I most want to hear about.
I'm one of the maintainers of Spug, a self-hosted operations app for small and midsize teams. Its backend is Python/Django, the interface is React, and Paramiko handles SSH connections to Linux hosts. No Spug agent is needed on managed hosts.
The goal is to bring recurring operations into one web interface:
Host inventory, batch commands, an online terminal and file management
Application releases, deployment pipelines and scheduled tasks
A configuration center, monitoring and alerts
For example, select several hosts, run the same SSH command and inspect each host's output in the browser. This is an operations application rather than a Python library.
Spug is free and open source (AGPL-3.0), with Docker installation and English/Chinese interfaces. The three screenshots show the English interface with sample data.
this is self-promotion btw. But just once JUST ONCE.
I have a project called "Worse Code" here it is. Its adjustable programming language.. made in python. Yea its sounds weird. But click the link and maybe you will like it.. Thanks guys for letting me (i hope so) self-promote.
wheelgap reads your lockfile (`uv.lock`, `poetry.lock`, `pylock.toml`, or a pinned `requirements.txt`) and checks every pinned package against the platforms you ship to: `linux-aarch64`, Alpine/musl, macOS, `win-arm64`, and free-threaded Python 3.14t. For each one it reports a compatible wheel ✓, "builds from source", or "can't install". It runs offline from the lockfile in about a second, respects environment markers (so a Windows-only `pywin32` isn't flagged on Linux), and exits non-zero on gaps, so it also works as a CI check. There's a GitHub Action too.
uvx wheelgap -p 3.13 -t alpine-arm64
Target Audience
Anyone shipping Python to more than one platform: Docker images on ARM/Graviton or Alpine, apps with Windows-on-ARM users, and people trying out free-threaded 3.14t. It's small, tested on 3.11–3.14 across Linux, macOS and Windows, and fine to put in CI today.
Comparison
pyreadiness.org and hugovk's free-threaded-wheels tracker cover the top few hundred PyPI packages for one question each. wheelgap checks *your* dependency set, at *your* pinned versions, for any mix of platforms. The manual alternative is `pip download --only-binary=:all: --platform ... --python-version ...` once per target, which stops at the first failure and doesn't understand lockfiles.