Disclosure: I own and sell CueKeeper. AI helped prepare this showcase.

CueKeeper is a local Python utility for an existing subtitle file, rather than an audio/video transcription tool. It converts SRT or WebVTT into readable Markdown/plain text, preserving cue intervals, and writes a separate quality report. An optional dialogue-only export drops the timing for reading.

The included example can be run from the extracted toolkit directory:

python3 app.py convert samples/valid.srt -o output --dialogue-only

That sample generates valid.md, valid.dialogue.txt, valid.report.json, and batch-summary.json. The two fictional cues become two timed passages; the report records parsed/emitted counts and any warnings or errors. A clean conversion report does not verify that captions match the recording.

The full toolkit needs Python 3.10+ and only the standard library. The ZIP includes Python source, tests, a sample, CLI, and local browser interface. It costs a one-time $1.00 USD through PayPal, or 1.00 USDC on Base: https://score.agentid.life/cuekeeper?ref=reddit-madeinpython-20261115

A separate free browser preview accepts up to 20 cues, so the output format is easy to inspect before purchasing: https://score.agentid.life/cuekeeper/try?ref=reddit-madeinpython-20261115

Public fictional sample input and generated files: https://github.com/nrk8286/agentid-services/tree/main/publishing/foundry-2026-11-12/samples/cuekeeper

It does not transcribe media, translate dialogue, or identify speakers. I would welcome feedback on which subtitle-quality findings are most useful alongside the reading copy.

Hi,

I’m currently working on developing add-ons for VenvHub Pro. It’s a new feature – a security audit of Python virtual environments (venv). The tool downloads vulnerability data directly from OSV.dev.

In the attached video, I demonstrate how the whole process works:

- Loading the list of packages from a specific venv environment.

- Then displaying an overview of which packages contain vulnerabilities.

- Clicking on a specific issue (CVE) in the tree structure immediately shows all the necessary details and description in the right panel and offers an update option.

- Clicking on the entire package shows an aggregated list of all its issues and available fixes in the right menu.

- Via the dropdown menu, the user can select a specific target version of the package with which they want to fix the given vulnerabilities.

From a technical perspective, the application is designed modularly. It uses dynamic UI generation based on the active provider’s schema (plugin auto-discovery). This means the architecture is not hard-wired only to OSV.dev, but can be extended with other security scanners.

Important note on versions:
The video and screenshots demonstrate the latest development version 2.6.08. The version currently published on my GitHub repository is 2.6.04, in which the scanner is not yet applied.

Since this is work in progress, I’ll be glad for any feedback. I’d be interested in your opinion on the UI/UX layout, as well as on the concept itself of selecting specific versions for fixes.

Thank you.

Hey everyone! I built a small CLI utility in Python with a clean terminal UI (powered by rich) called Mirrors.

Features:

• Downloads videos in MP4 (H.264) via URL (using yt-dlp).

• Extracts audio from videos into MP3 (via FFmpeg).

• Saves video thumbnails or direct image links as JPG.

• Displays real-time download progress, speed, and logs right in the terminal (adapted for Windows CMD, Linux, and Termux).

This is one of my first projects. Everything runs smoothly on my machine, but I'd really appreciate it if you could test how it runs on other systems and check if all dependencies install properly. Any feedback or code review is welcome!

GitHub repo: https://github.com/justiceDev1/Mirrors

TelaEdit is for people who write web pages by hand and want a straightforward, familiar tool rather than a full IDE. It takes its inspiration from the classic HomeSite editor, with up-to-date features added.

Main features:

- Syntax colouring for HTML, CSS and JavaScript, with tag-pair and bracket highlighting

- Tabbed toolbar for inserting tags: HTML, formatting, lists, tables, forms, HTML 5, media and text, plus a Quickbar for your own favourite buttons

- Link and image dialogs that work out relative paths and fill in image sizes

- HTML Tidy integration and a built-in CSS checker: click a problem to jump straight to it

- Spell checking of the visible text of a page

- One-click preview in up to ten browsers

- Two-panel file Explorer, snippets, templates and customisable keyboard shortcuts

It is written in Python with PyQt6 and QScintilla and released under the GPL v3. A standalone download is provided that needs no Python or Qt installed, and it has been tested on Linux Mint, Debian and Lubuntu.

Project page, downloads and screenshots:

https://github.com/toxtoo/TelaEdit

TelaEdit is a hobby project. I'm not a programmer: I designed and tested it, and it was written with the help of the AI assistant Claude. It's shared in the hope that it's useful to others, and feedback is very welcome.

Thank you for your time.

I made a 29 min clay film on a laptop. The part I didn't want to repeat was setting up every character, shot and voice by hand.

That turned into Clayvoyant. Write the scene in yaml viola it builds and films it in blender.

A quick look at how it works.

leakscan finds leaked API keys and credentials. pipx install leakscan, then leakscan scan . and it works, no config needed.

Besides normal folders and git history (including secrets someone committed and later deleted), it can scan Jupyter notebooks and tell you which cell and whether the key was in the code or the output. It can also scan Docker images layer by layer, and published packages before you install them, e.g. leakscan scan pypi:requests==2.32.3.

Every finding says what the key could be used for and where to rotate it. There's a --verify flag that checks whether a key is still live, but it's opt-in and asks for --yes on anything that isn't yours. No telemetry.

It also has a Python API, a GitHub Action, and a pre-commit hook.

Target Audience

People who want secret scanning in CI or pre-commit without a Go binary, and people who work in notebooks or want to look inside a package before installing it. It's young, so I wouldn't call it battle-tested yet.

Comparison

gitleaks and trufflehog are the established tools and they're good. gitleaks is faster (about 4.4x on the full history of the requests repo in my own benchmark, details in the repo), and trufflehog covers far more detectors and sources. Where leakscan is different is the Python install and API, notebook support, and the package scanning. If you need raw speed or the widest verification coverage, use those instead.

Repo: https://github.com/Vasishta03/leakscan

I'd really like to hear about false positives, and about any providers you want rules for.

Wanted to share a Python networking package I have been building and testing called pynltp (available via pip install pynltp, MIT licensed).

Why I wrote it:

I needed to pull 50 KB to 250 KB JSON sensor batches and send urgent control commands over lossy Wi-Fi and 4G links where 15% to 30% of packets randomly drop. Over normal TCP sockets, Python apps stall for 15+ seconds because the OS kernel assumes packet loss means router congestion and backs off the send window. Raw asyncio DatagramProtocol sockets avoid the stall, but you lose ordering, encryption, and any multi-packet payload if a single datagram disappears.

How pynltp works under the hood in Python:

1. Before encrypting or slicing a payload, it runs a compact pure-Python LZ4 block pass on repetitive JSON/CSV data, which usually shrinks telemetry batches ~6x so far fewer UDP packets hit the socket.

2. Each session performs an ephemeral X25519 key exchange (with optional pre-shared key), derives directional keys via HKDF-SHA256, and authenticates every UDP frame with ChaCha20-Poly1305 plus a 512-packet bitmask to drop replayed or spoofed packets in O(1).

3. Instead of stopping on every lost packet to wait for an ACK/NACK round-trip, each block is split into k systematic data shards plus m parity shards over GF(2⁸⁾ using precomputed 256-byte log/exp tables and Cauchy matrix inversion. As soon as any k shards arrive at the asyncio transport, the original buffer is reconstructed and SHA-256 verified immediately.

4. Urgent 1-packet reflex messages ride a separate packet type outside the bulk reassembly dictionary so alerts never get stuck behind a large file transfer.

Benchmarks and tradeoffs:

Using Linux tc netem set to 20% random packet loss and 80 ms RTT (10 runs each), transferring 100 KB of structured JSON took 2.65s +/- 0.31s with pynltp compared to 18.35s +/- 4.12s over kernel TCP BBR. On clean wired networks (<1% loss), standard TCP or asyncio streams are faster because the Cauchy parity shards add ~25-35% bandwidth overhead that is wasted when nothing drops.

It also speaks the exact same 16-byte binary header as a companion C99 Arduino library and JS client, so a Python asyncio server on a Raspberry Pi can talk directly to ESP32/ESP8266 nodes.

Source code, wire format docs, and netem benchmark scripts:

https://github.com/indian-aman/necklink/tree/main/packages/nltp

PyPI package:

https://pypi.org/project/pynltp/

Would appreciate any code review or ideas on speeding up the pure-Python GF(2⁸⁾ row-reduction loop!

Sharing v3.0.0 of NeckLink (pip install necklink, MIT licensed, Python 3.9+ with only NumPy required at runtime), a monorepo of six packages that compile subgraphs from the 157,789-neuron adult fruit-fly connectome (BANC v888) into runnable Python controllers and zero-float C99 cores.

All 6 packages on PyPI:

• necklink-cns: unified 4-organ reflex controller (11 brain populations -> 10 descending neurons -> 6 motor pools) with MAVLink v2 and ROS 2 bridges, plus necklink_cns.connectome tools for extracting BANC v888 subgraphs and running Maslov-Sneppen degree-preserving shuffles.

• neckcompass: central-complex ring-attractor heading and GPS-denied homing.

• necksight: optic-lobe LPLC2 + LC4 collision / thin-wire looming reflex with 3-DOF gyro derotation.

• neckcord: VNC 6x6 leg inhibition (emergent tripod gait), bounded rotor/thruster allocator, ESC fault observer, and 18-servo IK.

• necksense: mushroom-body 1,024 Kenyon-cell sparse projection for novelty detection and continual memory.

• pynltp: loss-healing asyncio UDP transport (LZ4 + X25519/ChaCha20-Poly1305 + GF(2⁸⁾ Cauchy FEC) for streaming reflex commands and telemetry across noisy wireless hops.

Minimal Python example:

import numpy as np
from necklink_cns import NeckLinkCNS

# Uses compiled BANC v888 connectome weights by default (or pass connectome_weights="v2_analytic")
cns = NeckLinkCNS(vehicle="hexacopter", grid_size=32)
out = cns.step(
    dt=0.02,
    speed_m_s=1.8,
    gyro_xyz=np.array([0.02, -0.01, 0.05]),
    accel_xyz=np.array([0.2, -0.1, 9.80]),
    mag_xyz=np.array([0.45, 0.05, 0.89]),
    camera_frame=np.full((32, 32), 160.0),
)
print(out.descending.behavior_mode, len(out.cervical_wire_4b), hex(out.mavlink_manual_pkt[0]))

The most interesting part of building v3.0.0 was auditing whether the real connectome wiring actually beats degree-preserving random rewiring (K = 100 Maslov-Sneppen shuffles where every neuron keeps its exact in-degree, out-degree, and weight multiset) and classical baselines:

1. Specific wiring matters on spatial geometry and coordination: scrambling the central complex or VNC matrices breaks closed-loop homing (100% arrival -> 4.7%, p = 0.0099), wave + 125 deg magnetic spike heading (12.84 deg RMS -> 62.82 deg, p = 0.0099), and emergent tripod gait (0.855 -> 0.411, p = 0.0099).

2. Specific wiring does not matter in the mushroom body: on UCI gas drift novelty detection, real Kenyon claws (0.666 AUROC) and shuffled claws (0.672 AUROC, p = 0.74) tie, while One-Class SVM hits 0.698.

3. Classical / symmetric models win raw accuracy: real fly circuits have biological left/right asymmetries (for example ~10 deg/s compass drift in darkness), so an EKF (0.81 deg RMS) or connectome_weights="v2_analytic" (80.0% closed-loop boat arrival vs 66.7% for BANC v888) beats raw biological weights when you just want the cleanest filter.

Live browser WASM simulator:

https://indian-aman.github.io/necklink/

GitHub repo & reproducible v3 benchmark suite:

https://github.com/indian-aman/necklink

Thick smoke kills visibility..

For years I kept a folder of small Python scripts I wrote for myself. None were impressive. No AI, no framework, no invention. They just saved me hours on weekends.

So I packaged 12 of them into GrabKit — a ready-to-run tool pack where every script opens with a dry-run preview and asks for confirmation before touching anything.

Design decisions that mattered:

1. Safety first. Every destructive action previews before it acts. Nothing is deleted without confirmation, nothing overwritten without a .bak backup.

2. Stdlib first. Nine of twelve tools use only Python's built-in libraries.

3. Plain English. Copy-paste examples in the README for people who never opened a terminal.

What I learned: boring sells. Nobody buys "AI-powered file organizer." They buy "sorts my Downloads folder in 3 seconds." The README is the product.

Free preview: https://github.com/Des3uct0r/grabkit

Built with Python 3.8+, Windows/Mac/Linux.

Standard desktop calculator apps force you to jump between keyboard and mouse just to click buttons. That kills flow when you’re doing multi-step math.

ViCalc is a lightweight Windows calculator built for people who actually like typing. Everything (scientific, trig, complex numbers, Programmer mode with bitwise + Base-N) is reachable via normal keyboard shortcuts and muscle memory.

Key features

• Full touch-typing control – scientific, trigonometric, complex arithmetic, and Programmer mode (Hex/Dec/Oct/Bin + bitwise) entirely from the keyboard

• Automatic HTML history logging – every session is saved as clean, structured HTML so you can archive, copy, or paste step-by-step work into notes/docs

• Flexible layouts – full visual controls, compact scientific, or minimalist zero-UI mode

• Complex number support with real/imag parts, polar form, etc.

• Open source (MIT), Python 3

Repo: github.com/Kudaschov/ViCalc

Would love feedback from the keyboard crowd. What calculator shortcut or workflow do you consider non-negotiable?

You rename a package, update its imports, and the tests are green. An architecture test that still points at the old directory can look green for a less useful reason: it isn't checking any files.

I maintain ArchUnitPython. Its file rules report an empty selection as a violation by default. I verified that with a cycle rule pointing at a missing directory, alongside a real dependency rule with both passing and failing imports.

This is useful for long-lived pytest suites where the architecture checks might be edited less often than the code they protect. A stale selector becomes something to fix instead of a rule that quietly disappears.

There is an option for intentionally empty selections, but keep that permission deliberate. A generated directory that is absent in one build is a different situation from a package path that nobody updated after a refactor.

The library gives you normal assertions through assert_passes, so this fits into the same test run as your behavioral checks.

Source: https://github.com/LukasNiessen/ArchUnitPython

I maintain Flama, an open source (Apache-2.0) Python framework I started in 2018 to get trained models out of notebooks and behind an API without writing a server around them.

Save a model with its metrics into a single file:

import flama
from sklearn.datasets import load_iris
from sklearn.neural_network import MLPClassifier

X, y = load_iris(return_X_y=True)
model = MLPClassifier(max_iter=2000).fit(X, y)
flama.dump(model, family="ml", path="model.flm", metrics={"accuracy": model.score(X, y)})

Then serve it:

pip install "flama[pydantic]"
flama serve --model file=model.flm,url=/model,name=iris

That's a running API with POST /model/predict/, input validation and interactive docs at /docs/.

LLMs work the same way: flama get downloads a model from Hugging Face into a .flm, and flama serve puts it behind OpenAI, Anthropic and Ollama compatible endpoints plus a built-in chat UI, on MLX (Apple Silicon) or vLLM (Linux with CUDA). Existing clients only need a base URL:

from openai import OpenAI

client = OpenAI(base_url="http://127.0.0.1:8000/openai/v1", api_key="local")

When a one-liner isn't enough, models become resources in a full ASGI app next to your own routes, with type hints driving validation, OpenAPI docs and dependency injection, and the hot paths (routing, JSON, request parsing) compiled in Rust and shipped as plain wheels.

Right now I'm working on the next release: Python 3.15 support and per-framework extras, so you only install the ML libraries you serve.

Repo: https://github.com/vortico/flama

Docs: https://flama.dev

Happy to answer questions, and if it looks useful, a star on GitHub helps more people find it.

Hello guys!

(If you saw my earlier post, pseudos is the new name for obsidOS.)

github repository

I would like to share my terminal pseudo-OS called "pseudos", built from scratch in Python!

Quick Start:

First, make sure to install the required dependencies listed in `pseudos_need.txt`.

Built-in Package Manager (pkgs):

It comes with its own simple declarative package manager configured in "pseudos/disk/_sys/packages.pseudos". To install a package, just add its GitHub link like this:

github = "https://github.com/`

The current release is v0.25 (migrated from the legacy obsidOS release), and new updates are on the way!

Hope you enjoy testing it out — feel free to report any bugs or share feedback on GitHub. Thanks!

I've been building Apsi alone for the past months, and 2.6.0 just came out. It's a Python-like language for AI and physics. Here's what's technically interesting about it, and what changed in this release.

**The core idea**

- Physical units and tensor shapes are checked before the program runs, so `metres + seconds` or a `(3, 4) @ (5, 6)` matmul is a compile error rather than a crash halfway through a training run.

- The compiler generates its own GPU kernels and talks to NVIDIA cards through the display driver only. No Python, PyTorch or CUDA toolkit is needed to train a model.

**What's new in 2.6.0**

*Whole-project Python conversion.* You can convert one file, a folder, or a whole project with everything it imports (`--plan` shows the result before anything is written). Getting this to work on real libraries (huggingface_hub, datasets, pydantic, fsspec, multiprocess) meant handling:

- import cycles (modules register as partial before they finish executing)

- `from . import x`, where `x` might be a submodule *or* a package attribute, decided at run time

- class bodies with `if TYPE_CHECKING:` branches and annotated fields under conditions

- parenthesised `with (...)` statements, where `with` is a soft keyword

*Type-proven fast paths.* When the compiler can prove a value is an int or a known container, `range` loops, counters, conditions, list/dict indexing, f-strings and struct constructors skip the generic dispatch. Across the benchmark suite, 2.6.0 is 1.28–1.35× faster than 2.4.4 (geometric mean, two runs). These paths turn off under exact-fraction arithmetic, where literals aren't machine ints.

*Odd-size matrix products.* GEMM sizes that weren't a multiple of 4 used to fall off the fast kernel. They're now zero-padded in a single kernel pass, and C is written in place when only K needs padding. That gave about 12% on a modern GPT config.

**Honest limits**

- All numbers come from one machine (Ryzen 5 5500 + RTX 3060 12GB). Raw logs are on the site, including runs where 2.6.0 lost.

- PyTorch is still faster on larger models (127M params).

- NVIDIA only for GPU work.

I'd especially like feedback on the unit/shape checking design, and reports of Python code the converter can't handle.

Site and docs: https://apsi.dev

Source: https://github.com/ATECTechnologies/apsi

I had already posted two blogs on image matching and wanted to build some basic application with that.

I used OpenCV to find keypoints in each image and match them between the photos. Then I used those matches to stitch the images together and generate one panoramic image.

Read more about it.

Et si vous pouviez transformer n'importe quel projet Scratch en une expérience Python entièrement programmable ?

Découvrez SKRASH.

Un projet open source qui explore une idée intéressante : exploiter les projets Scratch existants et débloquer de nouvelles possibilités grâce à Python.

Imaginez pouvoir dépasser les limites de la programmation visuelle traditionnelle, sans avoir à abandonner vos projets actuels.

SKRASH réunit ces deux univers.

GitHub : https://github.com/raidos23/skrash

Licence MIT.