🐍 Python — runs real CPython in WebAssembly (Pyodide), with 200+ packages available: numpy, pandas, scikit-learn, matplotlib, requests, regex, sqlite3...

First use of a package loads it automatically, so the basics are instant. 🟨 JavaScript — a sandboxed iframe with console output and a live DOM you can manipulate.

🌐 HTML/CSS — instant rendering with a live preview pane.

17 built-in example programs to learn from (data viz with matplotlib, web scraping, OOP, DOM animations, responsive design...).

Stop buttons for runaway loops (we've all been there). Dark neon UI, comments section, zero account required.

The math behind it: everything runs client-side — your code never leaves your machine. Free, no install, no server.

Try it here: https://perchance.org/ai-code-builder

Feedback very welcome — especially which packages/examples you'd want next. If there's interest I'll add more tutorials, more packages, and maybe a save/share feature.

I’m a product owner in a small team, and we were struggling a lot with marketing our Python SDK.
So I have built a tool that turns our documentations and code scripts into narrated video walkthroughs.

it actually runs the code in a sandbox, writes narration based on what really happened (not a generic script), records a real screencast, and voices it.

If you’re also interested, you can try it here:
https://orange-brackets.com

I’d genuinely love feedback, especially from anyone who’s tried to market a Python library/SDK.

I have built out a generic plugin packaging and loading system that uses the strategy pattern to allow you to pick and choose which parts you would like to change. Its only in 1.0 so there are definitely still things to be completed, but I am very proud of it so far. I would appreciate it if you could all check it out!

Currently, there is only 1 default strategy (consisting of several small parts/strategies).

Plugin Archiving/Packaging

Plugins can be archived. Via a a temporarily added entry to `sys.meta_paths` the plugin is able to use its own frozen dependencies. The module cache is brought back to its former state after a plugin has been loaded to ensure that the default application is not affected. This is important to have some kind of isolation. Of course, each part can be switched out and you can remove the isolation by modifying the loading strategy.

The plugin archiver (the default one) changes this plugin structure:

exampleplugin/
├── .venv/ # our virtual environment during development
│   └── ...
├── .git/
│   └── ...
├── src/
│   ├── main.py
│   └── plugin.toml
├── pyproject.toml # (`tool.plugin.src` is modified to be `src/` instead of `./`)
├── README.md
├── .gitignore
└── uv.lock

Into this:

author.exampleplugin.tar.gz/
├── site-packages/ # our virtual environment during development
│   └── ... # Various dependencies defined in pyproject `tool.plugin.includes`
├── main.py
└── plugin.toml

Importing Plugins

The library adds in import hooks that allow you to import plugins in this way:

import plugins.SomePlugin # imports __init__.py
#or
import plugins.SomePlugin.some_module
# or (entry point import)
import plugins.SomePlugin.__ENTRY__

Additional Features

- Plugin sorting, ensures dependencies are taken into account when determining plugin load order

- Dependency version checking

- Ability to determine the default module cache for plugins being loaded. Plugins do not generally have the ability to load project level modules/packages unless they are pre-loaded and stored in `utility.DEFAULT_MODS`. An easy way to update this is `utility.set_default_module_cache()`. This sets the default module cache to the current module cache..

- small command line entry point/script for packaging plugins with the default packager.

- Isolated pypi dependencies (`includes` feature) that lets plugins have their own dependencies without requiring the primary application to install anything from pypi or limiting the dependencies a plugin is allowed to have. I have seen this is generally missing from other plugin loaders. They expect plugins have the same pypi dependencies as the main application- this is obviously not always true. Note: package-info is included as well- so licenses are maintained/copied- which is very important.

- Limited loading of plugins from folders instead of tar.gz files.

To Be Completed

The only thing left to do is bug fixes, additional strategies, and full documentation. These will be added with in the coming weeks (especially documentation).

Links:

pypi: https://pypi.org/project/openpluginloader/

github: https://github.com/Summersweet-Software/OpenPluginLoader

This package makes customizing easier in pc the error is some functions Only work on windows btw 0.0.1 is very buggy pick 0.0.2 instead, any Comments about errors or any ideas? install in https://pypi.org/project/qyl/

I have been working on this package by my self for 3 days I think its better to be on windows but ill fix it later but here is the package https://pypi.org/project/qyl/ Any bugs or Comments of what should I add?

Hi all, I've been adding a load of beginner friendly coding exercises to my Python practice site. Would love to get some testing to see what you think :)

Python With James - Coding Exercises

Overview

Put simply, pyrig-runtime is a plugin system based on classes that declare functionality through code, and via subclassing these classes any state and functionality can be changed, removed or extended by overriding the methods of parent classes. For pyrig-runtime itself this applies to the CLI class it provides.

Specifically, pyrig-runtime defines one base class DependencySubclass at the root of this plugin system. All classes that inherit from it are automatically discoverable. The discovery is achieved as follows: pyrig-runtime builds a directed graph from all installed dependencies in the current Python environment, and finds all packages that have pyrig-runtime as their ancestor in the graph. Those packages are then imported and scanned for any classes that inherit from DependencySubclass. Through the DependencySubclass base class, every subclass has a .leaf() method that returns the leaf class of the inheritance tree. If several leaf classes are found by the discovery mechanism, they are dynamically merged into a single class with multiple inheritance. This is what lets independently installed packages cooperatively extend the same piece of behaviour. It is then simply possible in code logic to access the leaf and work with it.

Features

• Plugin discovery via classes — define a base class and its subclasses are discovered automatically across every installed package that depends on it without the need for registration. Learn more.

Documentation

For anything beyond this overview, see the Documentation.

I started this project because I kept thinking about a stupid failure mode:

print("API key:", api_key)

The secret is already exposed before a traditional secret scanner gets a chance to complain.

So I started building a small Python library to catch that.

It has... grown a bit.

You can literally do:

import secretshield

api_key = "sk-example1234567890abcdef"
print("Using:", api_key)

and SecretShield intercepts the output and turns it into:

Using: ********
⚠ secretshield: Potential secret detected and redacted.

It also protects Python's logging, including both %s arguments and f-strings.

Then I added a CLI:

secretshield run app.py
secretshield scan .

scan doesn't execute the code — it scans project files for likely credentials. It supports a bunch of common source/config formats and can output JSON, so it can also act as a CI check.

Then came the slightly more experimental stuff:

secretshield scan . --fix

For simple Python assignments, it can interactively move the detected value into .env, replace the assignment with os.getenv(...), update .gitignore, and create/update .env.example.

I made that deliberately conservative — if SecretShield can't confidently understand the code, it refuses to rewrite it.

There's also:

secretshield install-hook

which installs a Git pre-commit hook that scans the staged contents before allowing a commit.

And:

secretshield github-action

which generates a GitHub Actions workflow for scanning on pushes and PRs.

Under the hood, the part I found most interesting was the logging protection. Instead of putting a filter on the root logger, I use logging.setLogRecordFactory() so records created by child loggers are covered too.

The library itself has no third-party runtime dependencies and the detection engine combines known credential patterns with entropy-based detection.

Obviously this isn't supposed to replace proper secret management or Git/CI scanners. It's more of a defense-in-depth experiment for Python applications.

I'm mainly posting here because I'd love feedback from other Python developers:

Would you actually use something like this in a Python project?

And if you've built libraries that hook into stdout, stderr, or `logging: what edge cases am I probably missing?**

GitHub: https://github.com/Sam3360/secretshield

PyPI: https://pypi.org/project/secretshield/

Hey everyone! 👋

I built Cruise (cruise-lang v0.4.1), an open-source interpreted programming language made in Python that combines beginner-friendly syntax with deep learning tensor calculus!

Key Highlights:

• AST & Tokenizer: Built from scratch with scoped environment memory and recursive descent parsing

• Native AI Tensors: PyTorch autograd calculus (tensor([...], true)), loss functions (mse_loss), and optimizers (opt_adam, opt_sgd)

• Clean English Syntax: Supports 3 times write("Hi"), let x be 5, and modular fn ... end blocks

• CPM Package Manager: Built-in modular package manager (cruise install <pkg>)

• Desktop GUI Framework: Simple interactive Tkinter window builder with callback events

• REST APIs: Direct JSON HTTP requests using fetch() and post()

Try It in 30 Seconds:

pip install --upgrade cruise-lang

cruise

Quick Code Demo:

# Deep Learning Tensor autograd

let weights = tensor([0.5, 1.5], true)

let optimizer = opt_adam([weights], 0.01)

3 times write(weights \ 2.0)*

Project Links:

• PyPI: https://pypi.org/project/cruise-lang/

• GitHub: https://github.com/manjas-developer/Cruise

• Website & 0-100 Docs: https://manjas-developer.github.io/Cruise-Website/

Support My Open Source Work:

• Indian Users Support Here: https://buymeachai.in/manjasanand08

• International Users Support Here: https://throne.com/manjas-developer/item/d83a6389-fc12-4d64-a4e1-cf4dc4d1dc45

I would love to hear your feedback on the parser architecture and tensor features! Drop your thoughts in the comments!

I wrote a small utility that converts tree output into an Excel file. The code is far from ideal, but it does handle Cyrillic filenames on my own test data.

To make it more robust, I need to test it on real-world tree outputs — with varying nesting depths, special characters, long names, and so on.

If you have a moment, please share your tree.txt files (you can paste them in the comments or open a GitHub Issue) or just try the tool with your own data. This will help me catch the most non‑obvious bugs.

And of course, I’d be grateful for any advice — on code, tests, architecture, or just ideas for improvements.

Thanks in advance to everyone who responds!

Rep: https://github.com/Usdmal-tech/tree-to-excel

I made a python program on khan academy that asks you to enter a number, and some numbers have special responses. For example, entering "13" has a reference to how 13 is considered an unlucky number. I am new to coding; I learned the bare minimum from Khan's python stuff in order to make this masterpiece. Let me know how I did. I plan to keep adding new special numbers with unique responses.

The attached link will take you to my creation.

That is why I built pyrig to solve that problem. It is more than just a project scaffolder. It also supports you with maintaining a project over time.

What is pyrig?

pyrig is a package and tool that rigs up Python projects with Convention-over-Configuration. It scaffolds a complete, fully configured, installed and working Python project with everything a modern Python project should have and makes the process of developing and maintaining it more seamless and efficient by automating things like configuration management, CLI generation, testing infrastructure, and more.

Requirements

• Python 3.12+
• Git
• uv

Quick Start

uv init my-project --python 3.12
cd my-project
uv add pyrig --dev
uv run pyrig init

See the Getting Started Guide for detailed setup instructions to also fully integrate with GitHub and CI/CD from the start.

Features

Project Scaffolding & Initialization

The pyrig init command generates a complete project, this includes, but is not limited to:

• Standardized directory structure
• Fully configured dev tools (linters, formatters, type checkers, test frameworks, git hooks, etc.)
• End-to-end CI/CD pipeline with GitHub Actions and integrated repository protection
• Complete and working CLI
• And much more...

File & Configuration Management

pyrig manages and validates project files via classes, where every file is treated as a data structure (dict or list), the content is loaded and validated against the declared state in the class. This makes it possible to override and adjust any and all behavior of pyrig via subclassing said classes. pyrig will automatically discover and use your custom classes without any additional configuration. Run pyrig mk subcls to generate a subclass for any pyrig class. Run pyrig sync to create or update all config files at once.

Automatic CLI

pyrig init sets up a CLI for your project that works immediately. Generate and add new commands by running pyrig mk cmd <name>. An automatic version command is included that shows the version of your project. Run my-project version to see it in action.

Mirror Test Structure

Generate test skeletons with pyrig sync. This will generate test skeletons for all source modules and update them automatically as your project evolves.

Plugin Architecture

Override and customize any and all behavior to suit your project's needs. pyrig's classes are designed for inheritance and composition, allowing you to create custom configurations, tools, and more by subclassing and simply overriding methods. pyrig will automatically discover and use your custom classes without any additional configuration. Run pyrig mk subcls to generate a subclass for any pyrig class. Create your own plugins this way to extend pyrig's functionality.

CI/CD & Repository Protection

Pyrig generates GitHub Actions workflows for CI/CD which automatically test and release your code. They also configure and apply repository protection settings and protection rulesets. Push your code to GitHub after initialization and see it in action.

Commands

Run pyrig --help to see a list of all available commands and their usage. Run pyrig <command> --help for more information about a specific command and its usage. Run my-project --help to see the automatically generated CLI for your project.

Comparisons

pyrig isn't the only tool in this field. See how it compares to other popular tools like cookiecutter, copier or pyscaffold.

Documentation

Hey everyone!
I just released a small open-source Python library called FetchTune.
It’s a lightweight tool (both library + CLI) that takes music URLs from Spotify or Apple Music and returns clean, structured metadata — track title, artists, album, artwork, release date, duration, explicit status, platform IDs, etc.
It also has a simple enrichment feature that can fill in missing info (like album data) using other providers.

Repo: https://github.com/momalekiii/fetchtune

I’d really appreciate it if you could take a quick look and let me know:
• Any bugs or issues you find
• Things that feel incomplete or could be improved
• Feature suggestions (more platforms, better matching, etc.)
And if you like it, a star would mean a lot ⭐
Thanks in advance!

Hey everyone!

I'm a Python developer/student and I've been working on a small project called Find Everything 2.0.0.

It's a Windows desktop tool for quickly searching through files. I built it mainly as a learning project, but I tried to make it actually useful and polished rather than just another basic Python project.

Main things it currently has:

• Fast file searching
• Search inside files
• Dictionary / text processing features
• Windows .exe build
• Automated checks with GitHub Actions

Tech: Python, Windows, GitHub Actions

GitHub: https://github.com/EELDERONN/find-everything.git

I'd really appreciate it if someone could take a look at the repository and give me some honest feedback.

I'm especially interested in:

• Code quality
• Project structure
• UI/UX
• Performance
• README/documentation
• Things that could be improved or done differently

Feel free to be critical — I'm here to learn and improve the project.

Thanks to anyone who takes the time to check it out!

----------------------------------------

Я изучаю Python и сейчас работаю над небольшим проектом Find Everything 2.0.0.

Это Windows-приложение для быстрого поиска файлов и поиска информации внутри них. Изначально я делал его как учебный проект, но постепенно решил довести его до более полноценного и реально полезного приложения.

Что сейчас есть:

• быстрый поиск файлов;
• поиск внутри файлов;
• работа со словарём/текстом;
• сборка в .exe для Windows;
• автоматические проверки через GitHub Actions.

Стек: Python, Windows, GitHub Actions.

GitHub: https://github.com/EELDERONN/find-everything.git

Буду очень благодарен, если кто-нибудь посмотрит репозиторий и даст честный фидбек.

Особенно интересует:

• качество кода;
• структура проекта;
• UI/UX;
• производительность;
• README и документация;
• что можно было бы сделать лучше.

Можно критиковать — я как раз хочу понять, что можно улучшить.

Спасибо всем, кто посмотрит!

Hey guys,

you know how there is often convention over configuration in frameworks like e.g. django, so that you can just start coding and do not have to select every functionality yourself.

I wanted this for my python projects as well, having conventions but being able to configure everything still.

So I present pyrig

pyrig is a package and tool that rigs up Python projects with Convention-over-Configuration. It scaffolds a complete, fully configured, installed and working Python project with everything a modern Python project should have and makes the process of developing and maintaining it more seamless and efficient by automating things like configuration management, CLI generation, testing infrastructure, and more.

Basically it sets up things like type-checking, linting, testing and much more for you with good and strict conventions, which can still be configured differently if needed.

Go to https://github.com/Winipedia/pyrig if you want to know more and see the README and the documentation. It is way more than just another project scaffolder.

The full docs are at: https://winipedia.github.io/pyrig and there is also AI generated docs at: https://codewiki.google/github.com/winipedia/pyrig

Hi everyone! I wanted to share a project I have been writing in Python: Hillock, an open-source memory engine designed to run completely offline on laptops and budget hardware.

I wanted to see if I could build a deterministic memory system without relying on heavy cloud APIs or external vector database services.

How the Python architecture works:

• Vector Symbolic Math (reservoir.py): Built entirely with NumPy to handle a 10,000-dimensional bipolar vector space. To keep similarity gating fast on standard CPUs, I implemented a Sub-Dimensional Projection Cascade that evaluates a 2,000-D slice first for early rejection, keeping latency under 1 second.
• Relational Fact Store (database.py): SQLite handles Subject-Predicate-Object triples with micro-batched transactions and stores bit-packed multi-hop path vectors as compact BLOBs.
• Synaptic Co-Activation (plasticity.py): Implements gradient-free Hebbian updates across turns with per-turn exponential decay.
• Local Extraction (talon_engine.py): A pipeline combining Fastcoref, MiniLM, and GLiREL with type-constrained schema validation and direction auto-correction.
• Interactive Console (main.py): Features real-time token streaming from local Ollama models, live hardware tracking, and inspection tools.

We also have a standalone 21-point test suite (verify_hillock.py) to test the math and database semantics with zero GPU requirement.

Everything is open-source under AGPL-3.0.

I would really appreciate any thoughts on the Python code layout or NumPy optimizations!

Game Title: Estregg-ybj

Playable Command: estregg

Platform: MacOS, Chrome os, Linux terminal, Mobile Termux

Description: Hey guys, im YB-jeorge, a new guy and developer of making a game based terminal, on my first version there was flaws, on the second version had a few imperfection, and the third version? perfect and is now fixed and can be downloaded by typing "pipx install estregg-ybj in the linux terminal, bc its made with python 3, wine, curses, and pipx you can read the full Bio on here: https://github.com/corruption123ter-ux/estregg-ybj and make sure to read README.md , its a guide on how to download estregg, and also read the estregg-controls.txt, its a manual on how to control it, u can also go here https://corruption123ter-ux.github.io/estregg/ the main website for estregg and info you need, Thankie and have a good day!

https://github.com/open4dfoundation/Open4D.git

I rewrote my hobby language from scratch. It reads like a sentence, and a program starts with no permission to read files, use the network or start processes, you grant what it needs on the command line and anything else fails with the exact flag that would have allowed it.

Pattern matching, gradual types, async, modules, a test runner, a formatter and an LSP. Zero dependencies, Python 3.9+, Apache 2.0.

pip install she-lang

Runs in the browser, nothing to install: https://ni-sh-a-char.github.io/SHE/playground.html

Source: https://github.com/ni-sh-a-char/SHE

Short version: pip install breakcheck, then breakcheck demo --output-root .breakcheck/demo to watch it run with no external deps.

The itch that caused it: Dependabot opens a PR saying attrs 23 -> 24. My tests pass. Do I actually know nothing changed. Only for the behavior I happened to write an assertion for - everything else is a silent assumption.

Breakcheck discovers the calls my code actually makes into that library, replays them under both versions in isolated environments, and diffs what comes back. The same machinery compares two git revisions of your own code:

breakcheck diff --base main --head feature/refactor --fixtures breakcheck.fixtures.toml

The part I am most pleased with is that it refuses loudly. Every call site ends in exactly one state - EXERCISED, or one of G1_NOT_DISCOVERABLE / G2_NONLITERAL / G3_UNNORMALIZABLE / G4_IMPURE. It never pretends to have checked something it could not reach, so the coverage number is honest and often unflattering.

Scope is deliberately small: pure value-in/value-out calls - parsing, serialization, validation, encoding, schema coercion, deterministic numeric and string transforms. No network clients, no stateful objects, no dynamic dispatch.

MIT, zero runtime dependencies, Python 3.10-3.13, Linux and macOS. I would genuinely like to hear where it falls over on a real codebase.

https://github.com/lovettsendit/breakcheck

Posting here rather than r/Python since showcases moved over.

What it does. Takes a GitHub username and renders a single SVG summarising the profile: stats, contribution timeline, language donut, streaks, achievements. You drop one markdown line in your profile README and GitHub renders it as an image.

Why three services instead of one Flask app. The interesting constraint is the GitHub API rate limit. The obvious design fetches on request, which dies immediately: profile READMEs are hit by GitHub's camo proxy, not by humans, so one popular card can burn the quota for everybody. The split is:

• fetcher owns the PAT and a SQLite cache of raw payloads, and is the only thing that talks to GitHub. A cron refreshes on a schedule rather than on demand.
• generator renders SVG from whatever the fetcher last saw, and serves the React front end.
• edge is a cache-first proxy in front of the generator (Flask-Caching plus Flask-Compress, Redis optional).

Requests never block on GitHub. If GitHub is rate limited or down, you get the last good card instead of a blank one.

The bug that taught me the most. Five REST calls parsed .json() without checking status. A 403 rate-limit body is valid JSON, so it got stored as the user record and overwrote good data, while the metrics endpoint happily reported success. Every user touched would have served a blank card for 24 hours. A successful launch is exactly what triggers that, which is a nasty property for a bug to have.

SVG, not a chart library. The renderers return SVG strings built directly. Worth knowing if you try this: GitHub serves README images through a proxy that strips scripts and does not run CSS animation, so anything clever you do with <animate> or JS silently does not render for your actual audience.

MIT, and it runs on your own quota:

git clone https://github.com/ShayManor/github-readme-stats
cp .env.example .env      # GITHUB_PAT + an internal token
docker compose up -d --build

Repo: https://github.com/ShayManor/github-readme-stats

Hosted, free, no account needed: https://gh-stats.com

Known gap: organisation accounts render but commits and PRs come out as 0, because an org does not author commits, its members do. Personal accounts are what it is built for right now.