Hey everyone,

I just open-sourced TuneForge.

The goal is simple: let your coding agent manage the full LLM improvement loop without ever leaving the chat window.

You can now tell your agent something like:

“Build me a customer support bot from this FAQ”

…and it can:

• Generate a clean synthetic instruction dataset (with LLM judging for quality)

• Run LoRA supervised fine-tuning on any Hugging Face causal LM

• Do a quick policy-gradient RL step using Ollama as the reward judge

• Merge the adapter, evaluate on a test set, and iterate

Everything runs locally, uses 4-bit quantization so it fits on modest hardware, and uses background jobs (with job_id polling) so long training tasks don’t freeze the MCP connection.

It’s built around the Model Context Protocol (MCP) for seamless integration with Claude Desktop, Cursor, Zed, Continue.dev, etc.

Tech: Python + Transformers + PEFT + bitsandbytes + Ollama + SQLite for job state.

Super early stage (just released), MIT licensed.

Would love feedback or ideas on what to add next. If you’re into agentic fine-tuning workflows, give it a try and let me know how it goes!

Hi everyone! 👋

I've been developing Cobrapad, a Python game library built on top of Pygame to make 2D game development simpler.

This video shows a small arcade game built entirely with Cobrapad. The game is about 180 lines of Python code and includes:

• Player movement

• Falling enemies

• Collision detection

• Score and health system

• Main menu and Game Over screen

• Scrolling background

Cobrapad is still in active development, and I'd love to hear your feedback or suggestions!

🎵 Müzik:

https://pixabay.com/music/upbeat-game-8-bit-399898/⁠�

🐙 GitHub:

https://github.com/lorkas-052

📦 PyPI:

https://pypi.org/project/cobrapad/⁠�

What My Project Does

SOAR (Script Optimization and Automation Runtime) is a Python-based automation runtime system that helps manage and run scripts in a more structured way than simply executing standalone .py files.

It provides a lightweight runtime layer where users can:

• Organize scripts into projects
• Run automation tasks through a CLI-style interface
• Generate or scaffold simple project structures
• View basic diagnostics/log output for runs
• Experiment with modular “automation workflows” inside Python

The goal is to make small automation projects easier to manage without needing a full framework.

Target Audience

This project is mainly aimed at:

• Beginner to intermediate Python developers
• People who write lots of small automation scripts
• Developers who want a lightweight alternative to heavier workflow/automation frameworks

It is currently more of an experimental / hobby project than a production-ready tool.

Comparison

Compared to existing tools:

• vs plain Python scripts: SOAR adds structure and centralized execution instead of scattered files
• vs full workflow tools (Airflow, Prefect, etc.): SOAR is much lighter and not designed for large-scale pipelines
• vs CLI frameworks: SOAR focuses more on script organization + runtime behavior rather than just argument parsing

It sits somewhere between a script organizer and a minimal automation runtime.

Source Code

GitHub repository:
https://github.com/ScriptOptimizationAutomationRuntime/latest-version

(Additional resources like tutorials and updates are included in the repo.)

this video is me testing my first .exe after completing most of my to do list. up to the point i cant go further until i really start testing stuff looking for bugs i wont find otherwise. Its coming along. its for the most part working and doing what i should. i see the occasional hiccup but none of it breaking anything. just a slight freeze or lag. still got stuff to add, still got stuff to fix but its something. its no longer an idea, its no longer a hope, its real.

Hey everyone,

I just finished a project I've been working on intensely — a multi-layer QA automation ecosystem that tests a financial expense tracking app across every layer of the stack. Sharing it here because I want real feedback from people who do this professionally.

What it covers (4 test layers):

• Web — Playwright with strict POM (page objects hold locators only, zero logic), 10 tests including DDT from CSV, boundary testing, and data persistence checks
• API — Full CRUD against a custom Flask backend + JSON Server, 14 tests including 5 DDT datasets, negative scenarios (missing fields, bad routes, deleted IDs)
• Mobile — Android via Appium + UiAutomator2, 16 tests covering smoke, CRUD, DDT from JSON, boundary values, background persistence, keyboard interaction
• Database — MySQL 8.0 (via Docker Compose) with SQLite fallback for local dev. Tests validate data integrity using Set Theory (new_set - old_set) and SQL aggregations

What ties it all together:

• Cross-layer E2E tests — data entered in the Web UI is verified through API and then validated against the actual DB record. This is the part I'm most invested in — bugs at the seams between layers are what actually escapes to production
• 12-step CI/CD pipeline — GitHub Actions spinning up a MySQL service container, starting Flask + JSON Server, running all non-mobile tests, generating Allure Reports, and deploying them to GitHub Pages with 20-version history
• AI-powered failure analysis — Groq LLM integration that analyzes test failures and classifies root causes, triggered per-test via u/pytest.mark.use_ai or globally with --ai-analysis
• Centralized DDT — CSV drives Web tests, JSON drives API and Mobile tests, each record filtered by test_id so the same data file serves multiple test scenarios
• Custom Flask server — replaced json-server for the E2E/DB tests so that API calls actually write to MySQL, enabling real data integrity validation (not just mock responses)

Architecture (strict separation):

Tests → Workflows → Actions/Verifications → Page Objects + Data Layer

Every layer has one job: Page Objects hold only locator constants. Actions are u/staticmethod with u/allure.step. Workflows compose actions into business flows. Tests never call raw actions directly.

Some decisions I'd love feedback on:

1. For the E2E database tests, I used Set Theory (capturing DB state before and after, then using set difference to isolate the new record). Is this approach common in production environments, or are there better patterns?
2. The AI failure analysis adds ~2-3 seconds per failed test. Has anyone integrated LLM-based analysis into a real CI pipeline? Worth the overhead?
3. I built dual DB support (MySQL for CI, SQLite for local) — the Flask server reads DB_TYPE from environment. Is this a pattern teams actually use, or is it overcomplicating things?
4. Mobile tests are excluded from CI (require a physical device). What's the standard approach for running Appium tests in CI? Emulators? Cloud device farms?

The numbers:

Layer	Tests	Highlights
Web	10	CRUD, DDT (3 datasets), boundary, reload persistence, AI analysis
API	14	CRUD, DDT (5 datasets), negative (missing fields, bad route, deleted ID)
API ↔ DB	6	Create/update/delete reflected in DB, set theory integrity
Mobile	16	Smoke, CRUD, DDT (4 datasets), negative, boundary, background, keyboard
Cross-Layer E2E	3	Web UI → API → DB, negative amounts blocked by MySQL CHECK constraint
Total	53	9 test files across 4 layers

Context:

I'm a QA Automation bootcamp graduate transitioning into the industry. This was my capstone project. I deliberately went deep on architecture and cross-layer validation because I wanted to understand how data flows through a system — not just write tests that pass.

GitHub: Financial-Integrity-Ecosystem

Not looking for a pat on the back — I want to know what's missing, what's naive, and what would make someone reviewing this in a hiring context actually stop and look.

Thanks.

Hi r/commandline, I’m the creator of ShareClean.

It’s a small Python CLI for cleaning logs, stack traces, config snippets, and terminal output before pasting them into GitHub issues, support tickets, Slack, support threads, or other public places.

ShareClean is meant to be a quick local safety pass before sharing text publicly.

Example:

cat app.log | shareclean --report

Input:

user=user@example.com
password=fake-secret-value
postgresql://app:fake-pass@db.example.com/app

Output:

user=[EMAIL REDACTED]
password=[REDACTED]
postgresql://app:[REDACTED]@db.example.com/app

Why I made it:

I kept seeing people paste debug output that accidentally included tokens, local paths, emails, or connection strings. ShareClean is meant to be a quick local safety pass before sharing text publicly.

A few details:

• Local-first, no network calls
• No telemetry
• No runtime dependencies
• Redacts passwords, API keys, bearer tokens, JWT-like values, emails, local user paths, and optionally private IPs
• Has --check mode for scripts, hooks, and CI

This is not trying to replace full repo secret scanners like gitleaks or trufflehog. It’s for the smaller everyday moment where you’re about to paste logs somewhere and want to clean them first.

GitHub: https://github.com/OmarH-creator/ShareClean

Browser demo: https://omarh-creator.github.io/ShareClean/
(Demo is just to show the redaction behavior. Real use is local CLI.)

I’d appreciate feedback from people who use CLI tools often: does the workflow make sense, and are there redaction rules you’d expect in a tool like this?

​

Link of repo:

https://GitHub.com/coder-arnav66/Arnav-Python-Projects

I’ve been optimizing PythonSTL - a library that replicates C++ STL containers and algorithms in Python. To boost performance, I built a compiled Rust backend using PyO3 and Maturin.

After running benchmarks comparing Pure Python vs. Python + Rust vs. Pure C++ (O3), I encountered an amazing systems design paradox.

Here are the numbers and the engineering behind them:

The Wins (CPU-Bound Workloads):

• Bubble Sort (10k items): Pure Python took 5.4891s. Python + Rust took 0.0283s (a 194x speedup!).

• Binary Search (5k queries on 1M items): Python + Rust was 5.3x faster (0.0182s down to 0.0034s) by utilizing direct memory indexing without copying the list.

The Losses (FFI-Bound & Algorithmic Workloads):

• Stack (500k push/pop cycles): Python + Rust was only 1.47x faster (0.2324s vs 0.1581s). Why? Because calling push/pop from Python space crosses the Python-Rust FFI boundary 1 million times. The constant-factor cost of argument checking and GIL coordination dominates the runtime.

• Sorted Sets & Maps: Python + Rust was 5x slower! Why? Python’s native set/dict are highly optimized unordered O(1) hash tables. C++ STL compliance requires sorted keys, which we replicate using Rust’s B-Trees (running in O(log N) time) and calling back into the Python VM for comparisons.

The Core Takeaway:

Rust binary extensions are not a magic wand for performance. If your application does highly granular operations that frequently cross the FFI boundary, the boundary overhead will eat your performance gains.

But if you can bundle heavy calculations to run inside Rust with a single boundary crossing-it is an absolute game-changer.

Check out the project: https://github.com/AnshMNSoni/PythonSTL

I'd love to hear from other hybrid systems developers: how do you manage FFI overhead in your PyO3/Maturin libraries?

Thankyou.

About a year ago I started building Ducky a desktop Network & Security Toolkit built with Python and PySide6. I poured a lot of time into it, pushed it to GitHub, and... nothing. 50 stars. I figured nobody needed it, got demotivated, and basically abandoned the project.

Last week I randomly opened GitHub for the first time in months and saw 700 stars. That completely blindsided me and reignited my motivation to keep building. So I picked it back up and have been actively developing it again.

What Ducky does:

It's a one-stop desktop GUI for network engineers, sysadmins, and anyone who deals with networks replacing a bunch of scattered CLI tools with a clean interface. Everything runs locally.

Tools included:

- Network diagnostics: Ping, Traceroute, Network Monitor, Wake-on-LAN

- DNS & Email: DNS Lookup, MX Lookup, SMTP Test, Whois, DNS Propagation

- Network & IP: Port Scanner, IP Info, ASN Info, Subnet Calculator, MAC Vendor Lookup

- Website Analysis: HTTP Headers, SSL Inspector, Topology Map, Device Scan, ARP/Routes

- Security: Blacklist Check, CVE Scan, Password Checker, Hash Tool

Tech stack: Python, PySide6 (Qt6) - desktop app, no cloud, no telemetry.

GitHub: https://github.com/thecmdguy/Ducky

If you've ever wanted a Swiss Army knife for networking that isn't 10 browser tabs and 6 terminal windows, this might be for you. Would love any feedback - I'm actively building again.

hey guys there's this tool which lets you dictate nicely into claude code with technical + cursor terms, great for vibecoding. if you guys want to try, here's the link: github.com/eliasmocik/dum-dictation (we are building it on the side so if you guys like it or don't, please drop feedback would mean a lot ;)

https://imgur.com/a/dum-dictation-w9MIIT7

The difference in Python OOP between:

• instance method
• class method
• static method

visually explained using 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵.

Or see more memory_graph examples.

Hey there, everyone!

After watching No Text To Speech's video on how to create custom widgets, and seeing other people creating their own beforehand, I decided to give it a try.

I'm not new to programming, but I'm also not very good at it, haha... Despite that, I created a tutorial on how to set up a Last.FM widget and a Python script that will automatically update the statistics over on GitHub!

If you enjoy flexing your scrobbles on Last.FM, or even just keeping people up to date on what songs you're listening to, I think this might be the best solution! :D

If you would like to check it out, as mentioned earlier, I uploaded it to GitHub for all to use.

Have a good one, everyone! : ]

Hey everyone,

I wanted to share an open-source project I've been working on: Fırat University Assistant.

It’s a Turkish question-answering system that searches through local PDF documents (like student regulations, course contents) to find answers instantly. Instead of using expensive or slow APIs, I implemented a lightweight BM25 search index with Turkish-aware normalization.

Key Features:

• Offline First: Does not require an internet connection or external API keys.
• Tech Stack: Python 3.10+, FastAPI, pdfplumber, and Jinja2.
• Speed: fast indexing and retrieval without heavy GPU usage.

I built this to help students find information like "passing grades" or "absenteeism rules" quickly without reading through 50-page PDFs.

I’d love to hear your feedback or suggestions on the code structure!

Repo Link: https://github.com/Yigtwxx/FiratUniversityChatbot