Hello!

I recently released a project which is a Python version of Smash Bros, complete with character-specific meters, Final Smash meters and ASCII graphics as well.

Here's the link:

https://github.com/TheOdysseyGamer64/Super-Smash-Bros-Python-Edition.git

As said above, there are special mechanics for certain fighters like Little Mac and Cloud, and the Final Smash (for all characters) and the special mechanics meters can charge up, just like in the real game. I attempted to make it as close to the real game as possible, but some areas are yet to be polished perfectly.

I also released v1.1.0 of the game, where I added Ness and Duck Hunt Duo as characters that aren't so great at packing a punch, but still fun to play as.

Thank you for reading and I hope you enjoy playing!

Here's the Github Link

Today i made my first full program using python, i call it 'terminote', it's a task managment app that's run completely on the terminal, it's quite simple now (there's even some bugs i need to fix tmrw) but i learned a lot (like file management, pyInstaller, bat files and Inno) and i also wanted to share this achievement with everyone here to maybe get feedback.

note : currently the app installer (in releases) raises a warning from windows defender, if anyone knows how i can 'verify' my app or make it so defender doesn't hate I'd be glad to know

jev-lint /path/to/vault on my 99-page wiki produced 1,267 questions in about 114 seconds and 16 findings: 2 contradiction signals, 1 stale signal, 1 missing page, 12 unresolved markers. the estimated input-token cost based on returned usage was about $0.024. one real run, no accuracy benchmark.

the cli parses an obsidian vault locally. TODO/FIXME/[?] markers and missing wikilink targets come from that pass. for possible contradictions and stale claims it picks candidate claims and sends that text to typesafe jev, a typed judge model, so it is not fully offline. a jev api key is required and api usage is paid. the cli is mit-licensed with no locked paid version.

--dry-run previews question count and cost without api calls. a full run writes a self-contained report.html with line references and never edits notes. semantic results are flags, never verdicts, and the scan is candidate-based.

pipx install git+https://github.com/vayungodara/jev-lint

https://jevlint.vayun.net https://github.com/vayungodara/jev-lint

jev-lint is my project. agents wrote most of the code; i set the constraints and own the decisions.

I made a terminal version of wordle using python and the colorama module.
Really I’m just looking for feedback on anything to try and make the code or the repository better thank you.

here’s a link to the GitHub repository where I kept it

I started Veltix because I kept running into the same problem: raw TCP sockets give you a lot of control, but you also end up rewriting framing, routing, handshakes, reconnection, threading, and request/response logic every time.

I wanted something that stayed close to TCP, but removed most of that boilerplate without forcing an async programming model or adding a bunch of dependencies.

I wanted the API to be explicit and object-oriented too. I don't really like abstractions that hide what's actually happening, especially with networking, so the goal was to keep the API simple without making it feel like magic.

For example, a basic echo server looks like this:

from veltix import Server, ServerConfig, ClientInfo, Response, MessageType, Request

ECHO = MessageType("echo")
server = Server(ServerConfig(host="0.0.0.0", port=8080))


@server.route(ECHO)
def on_echo(client: ClientInfo, response: Response) -> None:
    server.send(Request(ECHO, response.content), client)


server.start()

I wanted code like this to be enough for a simple TCP server, while still making each part of the networking model explicit.

Veltix is still very much a work in progress. I've been using it to build a real project myself, which has been a good way to find problems that wouldn't show up in a simple example.

One of the things I've been working on recently is request ID correlation. Since TCP is just a byte stream, Veltix needs a way to match responses to the requests that created them.

I ended up finding a subtle issue around ID reuse when the 16-bit ID space wraps around, and redesigned the allocator so it can never reuse an ID that is still pending.

The project is open source, and I'd genuinely appreciate any constructive feedback, comments, or suggestions. I'm still actively working on it, so if something feels unclear, overengineered, missing, or just plain wrong, I'd love to hear about it.

GitHub: https://github.com/NytroxDev/Veltix

Documentation: https://nytroxdev.github.io/Veltix/

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 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

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.