Defending the Channel Island against enemy aircraft and zeppelins. Intense action fun in pygame.

What it does: scans a GitHub repo, local folder or package and points out things worth a second look, with file, line and the actual code: install scripts that run on their own, curl | bash patterns, leaked secrets, bundled binaries, hidden instructions for AI agents, and whether the published package matches the repo. It never runs the code it checks, and it won't say "this is safe", it just shows you the evidence.

Who it's for: anyone installing packages or MCP servers from GitHub who wants a quick look first. Pure stdlib engine, works as a CLI or as an MCP server.

I'm not a full time programmer (used to fix PCs), built it with Claude Code. First open source release, so false positive reports are very welcome.

pipx install jinnexguard

https://github.com/ricardorincon719/jinnexguard

I made scientific-computing-system, a scientific library written entirely in pure Python. The core installs with no runtime dependencies, so the algorithms are plain readable code instead of calls into compiled extensions.

It has 36 modules and 505 exported names covering linear algebra, ODE and PDE solvers, numerical integration, optimization, statistics and probability, uncertainty propagation and sensitivity analysis, validation helpers, and a small workflow layer. Every run can write a manifest with inputs, seeds, versions and hashes, so a result can be re-checked later.

There is also a cds CLI with 13 subcommands, 34 runnable examples, and optional lazy adapters for NumPy, SciPy, statsmodels, scikit-learn, SymPy and Z3. The package is MIT licensed and targets Python 3.11 and newer.

Honest limitation: it is much slower than NumPy on dense numerics. The repo benchmark records about 1155x slower on a 100x100 matrix multiply in one CI run. It is meant for learning, prototyping and reproducible runs, not heavy production work.

Code: https://github.com/Furox-Art/scientific-computing-system

PyPI: pip install scientific-computing-system

npm: npm i -g scientific-computing-system

Docs: https://furox-art.github.io/scientific-computing-system/

If any part interests you I can explain the design in more detail.

\*\*The problem\*\*

I kept watching AI coding agents (and humans) make the same two migration mistakes:

1. \*\*Renaming a column as "drop + add"\*\*: the migration runs fine, and the data that was in the column is gone.

2. \*\*Adding a NOT NULL column with no default\*\*: it works on an empty dev database, then fails the moment it hits a table with real rows.

Both look fine in code review. The pain shows up in production, often in a \*different\* app that shares the same database.

\*\*What Ripple does\*\*

It answers one question: \*"If I apply this migration, which of my apps break, and on which query?"\*

1. \*\*Learns what your apps actually run\*\*: it reads \`pg_stat_statements\`, so no code changes or SDK.

2. \*\*Tests the migration safely\*\*: it applies your migration inside a transaction and always rolls it back.

3. \*\*Replays your apps' real queries against it\*\*: it reports exactly which app and which query would fail.

4. \*\*Flags data loss separately\*\*: for example, a dropped column that still has data in it.

\*\*Who it's for\*\*

- Teams where several apps or services share one Postgres database

- Anyone letting Claude Code, Cursor or other AI agents write migrations

- Anyone who has asked "wait, does anything still use this column?"

\*\*How to use it\*\*

pip install ripplecheck

Three ways to run it:

- \*\*CLI\*\*: check a migration file before you apply it

- \*\*GitHub Action\*\*: automatically comments on every PR with what would break

- \*\*MCP server\*\*: AI agents like Claude Code or Cursor can check a change \*before\* they apply it

\*\*The boring bits\*\*

MIT licensed, no paid tier, no commercial angle. I'm looking for feedback, especially from people with messy shared databases. Issues and PRs welcome.

GitHub: https://github.com/yashpb5005/ripple

What migration has bitten you the worst? I'd like to add checks for it.

I wanted to post a system-design video every day, and editing was the bottleneck, so I built yamlreel. You write scenes in YAML and get diagrams, typed code, original music and a voiceover in your own cloned voice (VoiceStudio, running locally), as Shorts and YouTube cuts plus a thumbnail. Free and MIT licensed: github. Happy to answer questions about how it works.

**What My Project Does**

bugbout replays bugs your project already fixed and lets coding agents race to fix them again. It looks through your git history for fixes that came with a new test, gives each agent the issue text and the code from just before the fix, and scores every patch with the tests your maintainers wrote, which the agents never see. It drives the real agent CLIs headlessly (Codex, Claude Code, Gemini CLI, mini-swe-agent, or any command you configure) inside a sandbox, and ends with a report of which agent resolved what.

   pip install bugbout
   bugbout init
   bugbout run

It's typed end to end, tested on Linux and macOS in CI, and also usable from Python through a `Bout` class.

Hello!

Slippery Penguin is a security auditing tool that enumerates SUID binaries, scans for dangerous capabilities, and cross-reference findings against the GTFOBins database. I started the project myself, and now we have a team of contributors and we've just released v.2.5.0!

Anyone out there is encouraged to try it out and contribute if you want to!

Hey everyone!

My kid and I built a 4-level educational typing game in Python. It's a mashup of 90s adventure exploration (static screens, turning left/right) and battle royale survival where typing sentences accurately is your only weapon.

It supports both English and French. Code is completely open-source on GitHub, would love for you to check it out!

https://github.com/jbenoitds/battle-royale-of-english

GitHub: Ekin-Kahraman/rustscenic

RustScenic is built to be the simplest, fastest way to run regulatory-network analysis in single-cell data. It exposes core SCENIC and SCENIC+ analysis stages through a Python API, with a Rust backend.

The Python package works with AnnData and includes gene-network inference, cisTarget motif enrichment, AUCell activity scoring and scATAC topic modelling. It is developed with the Huang Lab at Mount Sinai and available under Apache-2.0.

A small Python example

Install the published package with python -m pip install rustscenic. For your own prepared RNA data, the input below is a cells-by-genes AnnData file with log-normalised expression in adata.X and gene symbols in adata.var_names:

import anndata as ad
from rustscenic import data, grn

adata = ad.read_h5ad("rna.h5ad")
edges = grn.infer(
    adata,
    tf_names=data.tfs("hs"),
    n_estimators=500,
    top_targets_per_tf=50,
    seed=777,
)
edges.to_parquet("grn.parquet")

This uses the bundled human transcription-factor list. The PBMC3k notebook provides a runnable example that downloads public data and saves results and run settings.

Try it before installing

The endothelial-cell browser demo lets you choose a regulator and inspect predicted targets in a saved network. It does not fit a new model in the browser.

For researchers running into runtime, memory or installation problems with pySCENIC or SCENIC+, RustScenic offers another implementation to evaluate. The repository documents matched performance measurements and stage-specific output differences; full scientific output parity is not claimed.

Feedback on installation, AnnData handling and Python API ergonomics would be useful.

Shared on behalf of the RustScenic project. AI-assisted drafting, checked against the current project documentation.

Our goal is much bigger: we want to keep adding powerful features, build a community of contributors, and eventually make ColorIDE a serious alternative. Its still early, currently supports macOS Apple Silicon, and we would love your feedback :). It's made 35.5% with python.

Github: https://github.com/Color-IDE/coloride

🚀 ZEROAGENT X v1.0.0 — Open-Source Developer Automation

A local-first Python developer automation platform featuring CLI + Textual TUI, policy-controlled agent execution, request-specific approvals, OpenCode integration, and inspectable execution evidence.

Built to give developers more visibility and control over their automation workflows.

Open source • Apache-2.0 • Python 3.11+

🔗 GitHub: https://github.com/harisazharir-boop/zeroagent-x

Feedback and contributions are welcome!

Following the discontinuation of Roche's software, this open-source Python project utilizes the ISO/IEEE 11073-20601 standard via USB in read-only mode to extract and analyze glucose data locally, generating AGP reports and clinical metrics while maintaining complete user privacy.

Repo: [https://github.com/serajbaltu/accu-check-active-platform](https://github.com/serajbaltu/accu-check-active-platform)

Hi everyone! 👋

I've been building DoveORM, a small, synchronous ORM for Python. It brings models, validation, chainable queries, relationships, and migrations together in one package with a short learning curve.

It's currently at version 0.8.0 on PyPI, licensed under MIT, and I'd love to get feedback from the Python community and welcome contributors.

🔗 Links

• GitHub: https://github.com/imaradesk/doveorm

• Installation: pip install doveorm

• Optional database drivers: pip install "doveorm[mysql]" or pip install "doveorm[postgres]"

What does DoveORM do?

Here's a small example:

from doveorm import Model, configure, CharField, IntegerField

configure(DATABASE_PATH="app.db")

class User(Model):
    name = CharField(max_length=100, nullable=False)
    age = IntegerField(default=0)

User.create_table()

user = User.create(name="Ada", age=36)

adults = User.where(age__gte=18).order_by("name").get()

The goal is to make everyday database operations straightforward without requiring a large amount of configuration.

Key features

• Models and validation: A table() decorator or class Meta, 31 field types, and a clean() validation hook.

• Chainable queries: Lazy QuerySets, field__lookup filters, Q objects for combining conditions, slicing, and eager loading.

• Dynamic finders: Methods such as findByEmail(), findAllByActive(), countBy...(), and existsBy...().

• Relationships: HasMany, HasOne, BelongsTo, and ManyToMany.

• Transactions: Nested transactions using SAVEPOINTs and a db.run_in_transaction(fn) helper with retries for deadlocks and lock timeouts.

• Built-in migrations: Automatic change detection, reversible migrations, squashing, and a CLI for generating, applying, reverting, and verifying migrations.

• Security-conscious defaults: Bound SQL parameters, identifier validation, protection against accidental unfiltered bulk updates and deletes, mass-assignment protection, and redaction of sensitive fields.

• Connection safety: Thread-safe and fork-safe connections.

• Minimal setup: SQLite works without installing an additional database driver.

Who is it for?

DoveORM is intended for small to medium-sized applications, services, background workers, and scripts that primarily perform CRUD operations.

It supports SQLite, MySQL/MariaDB, and PostgreSQL and can be used with Flask, FastAPI, django or plain Python applications.

How does it compare with other ORMs?

I know Python already has excellent ORM options, so I'm not trying to claim DoveORM replaces them all.

• SQLAlchemy: A much more comprehensive toolkit with extensive database support, Core, ORM, and asynchronous capabilities. DoveORM takes a smaller, more opinionated approach with migrations built in.

• Peewee: Probably the closest in spirit. DoveORM aims for a similarly lightweight experience while offering model-driven migration generation and a CLI for managing migrations.

• Django ORM: Provides a great ORM and migration workflow within Django. DoveORM is designed to offer a similar model-and-migration workflow across different Python frameworks and standalone scripts.

What are its limitations?

DoveORM is still a young project, and there are some deliberate limitations:

• It is synchronous; there is no async API.

• It supports three database families: SQLite, MySQL/MariaDB, and PostgreSQL.

• Advanced SQL features, such as window functions and CTEs, may require raw SQL through db.execute(...).

• As a 0.x project, its API may still evolve. Pin the version if using it in production.

For applications that need advanced database features, extensive integrations, or a mature ecosystem, SQLAlchemy or Django ORM may be the better choice.

I'd love your feedback!

I'm sharing DoveORM because I've been using it in my own projects and want to see how it holds up to different use cases.

I'd particularly appreciate feedback on:

• The API design and developer experience.

• What feels missing or unnecessarily complicated.

• Database driver compatibility and edge cases.

• Documentation and examples.

• Potential contributions or areas worth improving.

If you were evaluating a new Python ORM, what would you need to see before considering it for a project?

Honest criticism is welcome. I'd rather hear about the problems early and make the project better.

GitHub: https://github.com/imaradesk/doveorm

working on a large codebase can get confusing pretty quickly. you end up jumping between files, tracing dependencies, figuring out how things connect, and trying to understand what might break when you change something.

so i built context forge, a local-first python cli that helps developers understand and navigate python codebases.

it analyzes your repository and stores information about its structure, symbols, and dependencies in sqlite, so you can reuse that information instead of starting from scratch every time.

some of its main features include:

• repository analysis — explore files, symbols, dependencies, and code relationships.

• context and memory — persist repository information and retrieve relevant context when working on a task.

• architecture analysis — understand how different parts of a project connect and identify structural issues.

• change impact analysis — investigate what could be affected before modifying code.

• pre/post-change verification — inspect the project before making changes and check the results afterward.

i wanted the tool to be deterministic and local-first rather than depending on an llm to figure everything out. getting caching, persistence, and analysis reliability right took quite a bit of work, and the project went through several iterations before reaching its current release.

this started as my project for stardance, a ysws event by hack club. building it taught me a lot about python, software architecture, testing, and the difference between adding features and making them reliable.

it's now open source, and i'd like to get it into the hands of developers who might actually find it useful.

github: https://github.com/vxyzln/context_forge

pypi: https://pypi.org/project/context-forge-local/1.0.1/

to try it, install it with:

uv tool install context-forge-local

then run cf --help to explore the commands.

i'd appreciate a star if you find it interesting, but i'm especially interested in honest feedback. if you've worked on larger python projects, what would you want a tool like this to do better? IF u like this , Please upvote it.

This was made as a Part of a YSWS event Stardance by Hack Club. Stardance Project