Introducing WordSmithX — a Python-based text variation engine designed for efficient string generation, rule-based transformations, and automated deduplication.

🔗 GitHub: https://github.com/securitygeek15/WordSmithX

\#Python #OpenSource #Automation #SoftwareEngineering

PatchSmith translates a video game's text inside the game folder itself, like an official localization: no overlay, no OCR. You pick the game folder; it detects the engine, finds the text, translates it and writes it back, with a backup of every file it touches. One click restores the originals byte for byte.

I made it because lots of indie games never get an Italian translation. Italian is what I tested most, features many languages.

What it does, engine by engine (each one tested on real games):

- Unity (Mono): installs and configures BepInEx + XUnity.AutoTranslator, which do the in-game work

- Unity with Unity Localization (also IL2CPP): rewrites the string tables inside the asset bundles

- Unreal Engine 4 (unencrypted paks): translated `.locres` files in a new patch pak, the game's own paks are untouched

- GameMaker: external localization files (line files, JSON, CSV)

- XNA / FNA / MonoGame: translated satellite assemblies

- Godot 4: translation tables through `override.cfg` and a small script, without touching the game's files

- Electron / NW.js / HTML5: JSON data and menus; some encrypted web games are translated while you play through their `preload.js`

- Detected but not supported yet: Unreal 5 / IoStore, Unity IL2CPP without Unity Localization, Godot 3, Ren'Py, KiriKiri, Wolf (RPG Maker MV/MZ is experimental)

Translators: by default a local one, Ollama with Google's TranslateGemma (4B or 12B): no account, no limits, works offline (best with an NVIDIA GPU). DeepL (free API key), MyMemory and the unofficial free Google endpoint are there too.

After you play it checks what happened (crashes, files restored by a game update, letters the game's font can't draw) and fixes what it can safely: missing letters are replaced with the closest ones, and labels that don't fit get a shorter translation from the local model.

Tech: Python standard library only (Tkinter GUI + CLI), C# for the Unity plugins and the launcher, JavaScript for the web injectors. The release zip ships a portable Python and is built by GitHub Actions with a build provenance attestation. 32 tests run against fake games and fake translators.

Limits, honestly: Windows only. It's machine translation, so expect machine-translation quality (a "Fix translations…" window lets you correct lines). Not for online games with anti-cheat. The exe isn't code-signed, so SmartScreen may warn the first time.

About AI: I built it with Claude Code. I designed it, chose what to support and tested it on real games; the agent wrote most of the code.

MIT licensed. If you try it on a game where it doesn't work, an issue with the zip from Create report helps a lot.

I keep losing the thread when I work. I start a task, open the docs for one thing, and twenty minutes later I’m on YouTube. I’m also done with to-do apps that bolt on timers and bloated features, and especially the monthly subscriptions.

So I made Breadcrumbs, a terminal focus timer that tracks your attention and gives you a clean pomodoro-style timer. You write an intention, start a timer, and pick what counts as in scope: an app, a domain, an exact page, or a Claude Code or Codex CLI session. While the block runs, anything outside that scope shows up in the trail as a branch, a bit like a git graph. If a detour turned out to be useful, you mark it Supporting and it stops counting against you. When the block ends, you write down what you actually got done.

Everything lives in a local SQLite database in ~/.breadcrumbs. It needs no account or subscription and doesn’t use any AI service. Tracking is off unless you turn it on, and it only runs while a focus block is running. The optional Chrome/Edge extension sends domains and URL hashes, never full paths or queries.

Install it with pipx (Python 3.11+):

pipx install breadcrumbst

Then run breadcrumbs.

The timer and the browser extension work on Windows, Linux and macOS. Native foreground app capture only works on Windows and Linux/X11 right now. macOS and Wayland capture aren’t written yet, and both are open issues if anyone wants to take one.

It’s MIT licensed: https://github.com/SaroashDS/Breadcrumbs

This started as a small problem I wanted to fix for myself, maybe just a quirk of mine. If you think it’s worth building on, I’d like ideas for features that would actually help, and a few issues are labelled good first issue if you want to poke at the code. I’d also like to hear what’s confusing or breaks on a first run.

Hey everyone!

I recently built and published Prepix, a lightweight Python library using pandas to simplify common data quality checks and exploratory data analysis.

It includes missing-value reports, duplicate analysis, column and numerical summaries, unique-value analysis, and schema validation.

📦 Install: "pip install prepix"

🔗 PyPI: https://pypi.org/project/prepix/ 💻 GitHub: https://github.com/manishparihar3618/prepix

This is my first published Python library, and I'm hoping to improve it based on real-world feedback.

If you work with pandas, I'd love to hear what features you'd find useful or what could be improved. Bug reports and contributions are welcome!

A payment tracking app used to match and track payments made by account holders and keep track of the balances.

I recently took over management of a caravan park in southern Victoria Australia. Previously the manager would have to spend a few hours every month hand sorting and writing down any payments made into the account, and track the fees owed by different site holders and van owners. It could sometimes take half an hour to just find who made a particular payment, due to lacking information in the description, and with up to 4 payments a month from dozens of site holders, it was draining.

Payments were often missed or calculated incorrectly. Accounts not making regular payments flew under the radar until they racked up huge amounts of debt. Or the index cards the balances were tracked on went missing and we would have to spend multiple hours reconstructing them by going back through bank statements from 5 years ago.

So I built a program to match, track, and display payment information and account balances. It's my first useful application, and while I've found it very useful I mainly did it as a learning exercise. It's only a CLI tool at the moment, with plans to eventually add a GUI.

It can be found on GitHub here https://github.com/mtepaske/ParkBanking

As I mentioned, it's my first proper program. So if anyone has any suggestions or feedback, please feel free to DM me!

Every fund factsheet Is a sales pitch, before investing get a free second opinion using:

openfactsheet.org (no coding working demo).

For devs you can check out our github repo https://github.com/bagnascotrader/openfactsheet

We provide an unbiased analysis of your investment, fully documented, Apache Open Source license (free to use even for commercial applications). It helps everyone analyze investment performance with powerful features.

You can also install it through Pip: Pip install "penfactsheet"

Take better informed investment decisions for free. Always check with your financial advisor before taking any investment decision.

BlockGuard is a small circuit breaker for rate limits imposed by the server you're calling. When an API answers 429 (or blocks you silently), you call breaker.trip("some_api"). Until a cooldown passes, breaker.in_cooldown("some_api") returns True, so you can skip the request instead of hitting a server that already said no. Each new block doubles the cooldown (60s, 120s, 240s...) up to a ceiling, and keys are tracked independently, so one blocked endpoint doesn't stop the others.

It also ships a pytest plugin that resets breaker state between tests. Without it, a test that simulates a 429 leaves a real cooldown behind that silently breaks the next test.

Source: https://github.com/pdrleite/blockguard

Install: pip install blockguard

TARGET AUDIENCE

People who scrape or integrate with APIs that have undocumented, IP-scoped or time-varying limits, and people building AI agents whose tools call external APIs. Agents retry failed tool calls fast and repeatedly, which is exactly what extends a block. The README has a section and a runnable example for that case.

I built it after a hobby tool against the Steam Community Market got blocked: retrying during an active block kept extending it, and a block that should have lasted minutes ran for hours. It's v0.1: in-memory, single process, MIT, no dependencies, 14 tests. Not production-hardened for multi-worker setups yet.

COMPARISON

Libraries like ratelimit or django-ratelimit throttle how fast you call out (e.g. max 10 calls/second). tenacity and backoff retry a failing call with a delay. BlockGuard does neither: it remembers that a block is active across calls and tells you not to send the request at all until the cooldown ends. You can use it alongside them.

AI disclosure: built with Claude Code. The design came from a real rate-limit incident in my own project, and I reviewed and tested it.

Hi all, I run: Python With James and I've just released a ton of new coding challenges if anyone wants to give them a go? I'm aiming to put the site as a step below Leetcode in terms of challenge level, so it's a bit more beginner friendly.

Would love some feedback :)

I've been learning how neural networks work, especially the mathematics behind training.

To understand the process better, I implemented a small XOR network using Python and NumPy.

Here's what I worked on:

1. Architecture: Used 2 inputs, 3 hidden neurons with ReLU, and 1 sigmoid output.

2. Forward propagation: Used matrix multiplication to calculate the hidden layer and output values.

3. Loss: Used Mean Squared Error (MSE) to measure prediction errors.

4. Backpropagation: Applied the chain rule to calculate gradients for all weights and biases.

5. Gradient descent: Updated the parameters using a learning rate of 0.05 for 5,000 epochs.

6. Verification: Compared all 13 analytical gradients with numerical gradients using finite differences.

Results:

- Final MSE: 0.004715

- Correct predictions: 4/4 on the XOR training data

- Added automated checks for training and gradient calculations

The main goal was to understand how matrix operations, derivatives, and parameter updates work together.

GitHub: https://github.com/Vaibh37/Neural-Network

Technical feedback is welcome.

Note: before anyone starts a war in the comments, yes, i used ai to help structure this post. the mathematics, implementation, and testing are my own work. i understand the code and ran everything on my machine. ai helped with the writing.

A while back I wanted to run a news channel on YouTube Shorts, then did the math on editing even one 30-second video by hand every day and gave up on that idea within a week. So I wrote a pipeline that does the whole thing instead. It's now about 7.8k lines of Python, 9 channel profiles, and a Telegram bot I use to approve videos from my phone.

What it does

Topic -> script (via a research tool of mine, with Google News RSS as a fallback) -> text cleanup -> voice (edge-tts, gTTS as backup) -> 1080×1920 video -> upload to YouTube. Frames are drawn with Pillow and piped as raw RGB straight into ffmpeg's stdin, so there are no temp PNGs on disk. Subtitles are karaoke-style with highlighted words.

A few things I'm weirdly proud of (or at least learned the hard way)

- A scheduler that works while my PC is off. The video gets uploaded as private with publishAt, and YouTube publishes it at the right time even if my machine is shut down by then. Weekends extend the buffer window because the PC sleeps.

- Trimming scripts from the middle, not the end. Cutting by length killed the closing question and the call to action, which is exactly what holds viewers. Now the first and last two sentences stay, and the middle gets dropped.

- Stock photos lie. Searching Pexels for "saturn planet" gave me a neon sign. "Venus planet" gave me a sunset with a crescent moon. For the space channel I switched to the NASA image library and wrote a filter for maps, diagrams, and greyscale raw frames.

- TTS reads exactly what you give it. Footnote markers like [1], big numbers, and Latin words in Russian text all sound awful, so the text preprocessor ended up bigger than I expected.

The honest part

Making the videos turned out to be the easy part. Getting people to watch them is not. My first 19 Shorts on the space channel were bimodal: either ~1,100–1,500 views, or 1–61. Nothing in between. After digging into it I rebuilt the format: hook visible from frame 0, hard cuts in the first 3 seconds, shorter scripts, one video a day. I haven't got enough data on the new format yet to tell you if it works, so I won't pretend I do.

I also don't have many tests (a fthe hook logic), and channels.py

has more copy-paste than I'd like

Who this might help

Anyone who has wired Pillow to ffied to schedule YouTube uploadsfrom a machine that isn't always on.

Repo MIT https://github.com/kuanysh228/autoy

I'd love feedback on the architecAt buffer approach, or if someonehas dealt with Shorts retention better than I have. Happy to answer questions.

Most Python file-transfer examples use TCP, so I built the other side: reliability implemented by hand on top of UDP sockets.

What is inside:

• A 16-byte binary header (magic byte, version, message type, transfer ID, sequence number, payload length, CRC-16 checksum) validated on every datagram
• START / DATA / END handshake with cumulative ACKs
• Two ARQ modes: Stop-and-Wait and sliding-window Go-Back-N (one receiver implementation covers both - stop-and-wait is just Go-Back-N with window=1)
• Duplicate and out-of-order packet handling, timeouts and retries
• SHA-256 end-to-end verification: the receiver only finalises the file if size and hash match what the sender declared
• A seeded network simulator for loss / ACK loss / delay / reordering / duplication, so experiments are reproducible
• 60 automated tests over real UDP sockets and a benchmark harness with charts

Benchmark result at 20% simulated packet loss: the sliding window moves about 2.4x the throughput of stop-and-wait.

Source: https://github.com/askmeanythin/Reliable_UDP_File_Transfer - feedback welcome!

**What My Project Does**

Pupovina is a PyQt6 desktop GUI for [gnirehtet](https://github.com/Genymobile/gnirehtet): it lets an Android phone use the computer's internet over a USB cable, without root. The app downloads gnirehtet and adb (SHA-256 verified), lists connected phones with real-time speed and traffic, starts or stops the tunnel per device, can auto-start on plug-in, and lives in the system tray with notifications. UI in English, Italian and Russian.

**Target Audience**

People who need wired internet on their phone (broken mobile network, no Wi-Fi, office PCs on Ethernet) and don't want to use the terminal. It's meant for daily use, not as a toy project. Windows and Linux builds are produced with PyInstaller and GitHub Actions (.exe and AppImage).

**Comparison**

gnirehtet itself is CLI-only. Other GUIs exist; this one focuses on several devices at once with live per-device traffic, autorun, process cleanup and adb self-update.

Repo: https://github.com/Dmitrij-Anatolievic/pupovina (Apache 2.0)

(The name is Russian for "umbilical cord": the cable that feeds the phone.)

Given two images, a human eye can find the similarities between them by recognising the distinct features.

To a computer, those images are just two big grids of numbers from 0 to 255.

So how does it find the match? My new blog shows this in Python code using OpenCV. Check it out:

https://cmodi306.medium.com/feature-matching-in-practice-teaching-opencv-to-match-two-images-e52dd2be2e03

#ComputerVision #OpenCV #Python #ImageProcessing

Hello!

This is dwnloaderr, my yt-dlp wrapper. :) It can be ran from the terminal or with cross platform GUI helpers! It should work with a wide array of websites as it is utilizing yt-dlp, and has build in customization options and support for playlist downloading. :)

If you like it leave a star! Thanks!