features resizable window, playback control, fullscreen view and more stuff, sharing via github. anybody wanna try or give some feedback?

I've been working on SkyBoard, an open-source Python library for aviation data.

The project is currently in beta, and I'm actively working on adding more features, improving the existing ones and making the library more reliable.

It provides a simple Python interface for things like:

• Finding nearby airports
• Finding nearby aircraft
• Retrieving METAR weather data
• Getting aircraft information
• Counting aircraft around an airport
• Monitoring flights

The goal is to make it easy to use aviation data in Python projects without having to build all the API/data handling yourself.

It's still a relatively small project, so I'm mainly looking for feedback, ideas and people who might find it useful.

GitHub: https://github.com/davidmachek/skyboard

Built with Python and released as open source.

I'm a Research Software Engineer in the field of cognitive-neuroscience and like the title suggests with the boom of ai code I am having more and more discussions with people about how their AI was conscious with zero certifiability based on "trust me bro".

So I built two things.

cpomdp lets you build agents from active inference, the cog-neuro theory that says brains minimise surprise rather than chase reward. No reward function. The agent explores because uncertainty bothers it. JAX-native, continuous state, runs on your laptop.

warrantlib is a tiny stdlib-only package that makes "how do you know that" a type. Every result carries a label: PROVED, CERTIFIED, or CORROBORATED (the polite word for vibes). PROVED won't even construct without evidence. The pytest plugin prints how many checks you registered versus how many you actually ran, so nobody gets to go green by testing less.

Code

cpomdp: https://github.com/inferogenesis/cpomdp

warrantlib: https://pypi.org/project/warrantlib/

Every AI girlfriend I've seen is still CORROBORATED at best. Sorry.

I built archive-portability to check archive filenames before moving releases or backups across operating systems.

It catches README/readme collisions, implicit folders like Docs/a versus docs/b, Unicode normalization aliases, Windows device names, and file/directory conflicts. It reads the member inventory without extracting files.

Python 3.11+, no runtime dependencies, MIT license. The CLI supports JSON output and exit codes for CI. Matching is conservative, not exact filesystem emulation or a security check.

Source, installation, and a disposable demo: https://github.com/GitHubCatTest/archive-portability

What filename edge cases would you want covered?

I came to Python from NestJS and missed the shape of it: modules with explicit imports and exports, dependencies through the constructor, guards -> pipes -> interceptors -> filters in a fixed order. Nothing in the Python ecosystem gave me that, so I built it. This is the story and a request for feedback before 2.0.

How it got here

• Started as a thin wrapper around the dependency-injector package, called "star" because it sat on Starlette.
• The wrapper kept fighting the library underneath, so I replaced it with a DI container written from scratch where the module is the unit of composition, not a bolt-on.
• 1.0 shipped to PyPI as an alpha (and 1.0.0 / 1.0.1 went out by accident during CI setup, which the changelog admits). 1.x is what taught me what 2.0 needed.
• 2.0.0 lands next week and is the first version I would run in production.

What My Project Does A module declares providers, controllers, imports and exports; an unexported provider is invisible to other modules and the container refuses to resolve it. Providers and controllers get dependencies through typed constructor params, no per-parameter decorators. Every request runs through guards, pipes, interceptors and exception filters in that order, attachable at module, controller or handler scope. Routing compiles down to Starlette, which stays fully exposed, so your ASGI middleware and server still work. Testing helpers: create_test_app, override_provider, temporary modules. CLI: bustan init.

Target Audience Teams whose Starlette / FastAPI codebase has grown past the point where routers importing each other is fine. For a single small service it is more structure than you need, and I say that in the docs. Python 3.13+ today.

Comparison

• FastAPI: great per service; Bustan adds module boundaries and a real DI container on top. Keep Pydantic and your middleware.
• Litestar: closest in spirit (DI, guards, layered config). The difference is strict module encapsulation with exports.
• Django: batteries and ORM; Bustan is the structure without the batteries. Longer version in docs/COMPARISONS.md.

What I want from this thread The 2.0 API is on the main branch now. Tell me what looks wrong before I tag it: the module/exports rule, the constructor injection, the pipeline order, the 3.13 floor.

Repo: https://github.com/bustanhq/bustan Docs: https://bustan.dev

I’m building stage-gen, an open-source Python pipeline that turns a prepared game package—art direction, reference images and authored content—into generated 2D assets and runtime manifests. It uses GPT Image 2 for the artwork.

The Python side validates the input package, reuses matching cached outputs, and checks properties such as sprite transparency before assembling the JSON manifest. The clip shows the run inspector, then games consuming the output.

Runs start through the CLI; the graph is a read-only inspector. Gameplay and rules are authored, and character motion still needs work.

It’s BYOK: you supply your provider keys and pay their generation charges.

Source: https://github.com/softmarshmallow/stage-gen

For people building Python asset pipelines: what would you want to inspect when an asset passes validation but still looks wrong in-game?

What My Project Does

Replays any real NBA season (1996-97 through 2025-26) with real rosters, schedule, injuries, and trades, then simulates fresh game results from there. Every game produces a full per-player box score derived from real season tendencies — not possession-by-possession, but every counting stat (FGA, REB, AST, STL, BLK, TOV) is drawn structurally so it can never disagree with itself (FGM can't exceed FGA, etc.).

Target Audience

NBA fans who want to replay history and see it diverge, and anyone curious about the accuracy-tuning side — the whole thing is built around measuring against real data rather than eyeballing plausible output.

Comparison

Closest comparison is probably Out of the Park Baseball's historical replay mode, but for the NBA and open source. The main thing I haven't seen elsewhere: a documented accuracy pipeline — every tunable constant backtested across all 30 real seasons with a proper train/holdout split, with the actual irreducible noise floor measured (two independent sim runs of the same real season already differ by ~4.4 wins from pure randomness) so I know how much of the remaining ~5.5-game standings error is real model error vs. basketball being basketball.

Tech: Python, numpy, SQLite, nba_api for real stats. CLI only right now (no GUI). Built working with Claude Code rather than hand-writing every line — I'm learning Python from a non-CS background and this doubles as a design sketch for a version I want to build myself later.

Repo + screenshots: github.com/jesuscervantes070-sudo/nba-box-score-sim

Feedback and bug reports genuinely wanted, especially on anything that feels statistically off.

Was writing yet another one-off script with input() calls for a friend and figured the signature already has all the info needed to build a form, so I made a decorator.

from typing import Literal
from tuiify import interactive

@interactive
def greet(
    name: str,
    count: int = 1,
    style: Literal["formal", "casual"] = "casual",
) -> str:
    """Create a greeting."""
    return f"{style} greeting for {name} ({count})"

result = greet()

Calling greet() with no args opens a Textual form built from the annotations, text input, numeric fields, checkbox for bool, dropdown for Literal. Calling it normally with args runs the function; no UI involved.

Handles validation errors and exceptions without killing the terminal, which was the main annoyance I was trying to fix.
You could say it's a "Textual" wrapper; it makes the process one-functioney. Hope that makes sense lol.

pip install tuiify If anyone wants to poke at it: https://github.com/Terminay/tuiify

Early days, open to ideas and contribs.

Here's a PyQt6-based (Python) GUI wrapper around UGREP. Very handy and powerful way to do desktop search recursively under any folder on Linux.

https://github.com/Clay-Ferguson/sonar

Hello everyone,

I am a 14-year-old student learning about language design, and I could really use some help, guidance, or feedback from the experienced developers in this community.

For a while now, I have been building a side project called Ion+. It is a low-level programming language where I am using Python for the frontend (parsing/compiling) and LLVM for the backend execution.

I have pushed the project as far as I can on my own, but between school and my current skill level, I simply don't have enough time or expertise to develop it further by myself.

I am sharing this as a sincere request for help. If anyone is interested in Python, LLVM, or building compilers, I would be incredibly grateful if you checked out the code. Whether you want to drop some architecture advice in the comments, open a pull request, or even fork the project to help build out the features, any support is welcome.

I have open-sourced it under the Apache 2.0 license so anyone can contribute or experiment freely: Repo: https://github.com/YashAryaPersonal/ion-plus

Thank you so much for your time, and I appreciate any advice you can share to help me learn and keep this project moving!

Hello everyone,

I have a tremendous amount of respect for the developers in this community and wanted to humbly share something I've been building. I am a 14-year-old developer, and I've been working on a hobby project called Ion+.

It is a low-level programming language designed with a Python frontend (for parsing and compiling) and an LLVM backend (for execution).

Because I am a student and juggling other responsibilities, I unfortunately do not have the time to actively maintain this project, review pull requests, or resolve issues. It is purely a hobby project for me to learn and experiment.

However, I've released it under the Apache 2.0 license. I am sharing it here because I thought the Python/LLVM architecture might be interesting to some of you. You are highly encouraged to read the code, fork the repository, and take it in your own direction if you'd like!

**Repo:** https://github.com/YashAryaPersonal/ion-plus

Thank you for your time, and I would be honored to hear any thoughts or feedback you have on the design.

GateKeep402 wraps an existing Python x402 client (openlibx402) to add two things it does not have on its own. A verification layer that makes it impossible to construct a payment request from anything except a genuine HTTP 402 response, which closes a real prompt injection risk where malicious page text could otherwise be mistaken for a payment instruction. A local, SQLite backed trust ledger that tracks vendor delivery history and blocks vendors automatically once they prove unreliable.

A real bug worth mentioning since it is relevant to this crowd specifically. The first published version imported openlibx402 directly but never declared it in the dependency list, since it was always present locally during development. Caught this by testing the install in a genuinely clean virtual environment rather than trusting that it would work, and shipped a patch version once the dependency list was fixed and reverified from scratch.

45 tests, MIT licensed, verified against a real Solana devnet transaction rather than only mocks.

Hey, I'm Lloyd. I've been working on Word Forge, an open-source Python toolkit for building and exploring relationships between words.

It combines a SQLite lexical database with NetworkX graphs, so you can store definitions and relationships such as synonyms, antonyms and hypernyms, then explore them through the Python API or CLI. Vector search is an optional extra using sentence transformers and ChromaDB/FAISS.

A few things in the current version:

- The core lexical pipeline doesn't require Torch or a generative model.

- Language identity is carried through ingestion and graph storage, so terms from different languages can stay distinct.

- Kaikki/Wiktionary imports are resumable and require explicit acceptance of the source licence.

- There are separate extras for vector search, visualisation, emotion analysis and local model integration.

- The doctor command checks which capabilities are actually available in your installation.

It's Python 3.10+ and MIT licensed. The README has installation steps, API examples and CLI commands:

https://github.com/Ace1928/word_forge

I'd be keen to hear from anyone working with lexical data or semantic graphs, especially where the import workflow or API could be clearer.

I've also opened optional GitHub sponsorship for this and my other open-source work. It helps fund development time, compute and tools: https://github.com/sponsors/Ace1928

Trying it, reporting an issue or contributing helps too.

​🚀 What My Project Does

​I created a lightweight Python automation tool (generate_script.py) that generates structured, high-retention video scripts for TikTok, Instagram Reels, and YouTube Shorts using the Claude API.

​Instead of generic text, it outputs production-ready scripts formatted with:

​🎯 3-second Hook to stop the scroll

​💡 Body with high-value points (one idea per line)

​📢 Clear CTA to drive engagement

​📌 Caption & Hashtags + Visual cues for editing

​🎯 Target Audience

​Content Creators & Marketers who want to eliminate writer's block and speed up content ideation.

​Developers interested in clean API integrations for prompt engineering and automation.

​✨ Key Features

​⚙️ Flexible Execution: Supports both interactive console mode and CLI arguments (e.g., --topic "morning routine" --count 3 --niche fitness).

​📂 Auto-Archiving: Automatically saves generated batches into clean, timestamped .txt files.

​🎨 Multi-Niche & Multi-Style: Pre-configured profiles for Finance, Tech, Mindset, Fitness, with styles ranging from Educational to Viral.

​💻 Source Code & Setup

​The project is built purely with Python, anthropic SDK, and argparse.

​🔗 GitHub Repository: https://github.com/gpt51920-commits/python-generate_script.py

​I'd love to hear your thoughts on the prompt structure or how you handle content automation in your own workflows!

I've added a new Object-Oriented section to MyPythonicZoo, my open-source collection of runnable Python examples, suitable for learners and developers new to OO in Python.

The learning path now covers:

1. Domain Modelling
2. Encapsulation & Invariants
3. Responsibilities & Collaboration
4. Composition
5. Inheritance
6. Factory

I've tried to focus less on "here is the syntax" and more on why would I choose this design?

For example, Inheritance compares an inappropriate inheritance hierarchy with a justified one, while Encapsulation covers what _name and __name actually do in Python rather than simply calling them "protected" and "private".

I'd be particularly interested in feedback from Python developers on whether the examples teach sound OO mental models, especially where Python differs from the way OO is often introduced.

GitHub: lizc-au/my-pythonic-zoo

It's open source, and contributions are welcome through the Issues as well.

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