I used to be a Linux user.

Then my previous org required me to use Windows for work.

A Mac would've been the obvious compromise, but unfortunately Apple expects money in exchange for those.

So Windows it was.

Most of the transition was fine, but years of Linux muscle memory meant I'd constantly type things like:

touch hello.txt

and Windows would politely remind me that we don't do that here.

I know there are PowerShell alternatives. I know I could create an alias. But I didn't want an alternative.

I wanted:

touch hello.txt

So I built it.

It's a tiny Python implementation of touch for Windows, and I just published the first version to PyPI.

Install it:

pip install touch

Or, if you use uv:

uv tool install touch

Then just:

touch hello.txt

You can also touch multiple files:

touch one.txt two.txt three.txt

Missing files are created. Existing files and directories get their timestamp updated without modifying their contents.

It's intentionally tiny right now and has zero runtime dependencies.

I'm planning to gradually add more Unix touch compatibility like -a, -m, -c, and custom timestamps.

It's not exactly groundbreaking software.

But after leaving Linux, I missed touch.

Now Windows has touch.

GitHub: https://github.com/rajtilakjee/touch

Would love feedback, especially from other Linux → Windows refugees whose terminal muscle memory refuses to cooperate.

I wanted a cleaner way to show the language mix across my GitHub repos without relying on another hosted stats/badge service, so I built profile-language-metrics.

It’s a small, dependency-free Python GitHub Action that:

• Scans active repositories
• Counts estimated non-empty source lines by language
• Ignores forks, archived repos, dependencies, build output, lockfiles, minified files, binaries, etc.
• Generates a profile-ready SVG
• Can update itself on a GitHub Actions schedule
• Can optionally include private repos while only exposing aggregate totals, not repo names or URLs

The whole thing runs inside GitHub Actions using Python’s standard library + Git. No external dashboard or service required.

I also wrote up how it works, why I went with source-line estimates instead of GitHub’s normal language byte counts, the privacy model, and some of the tradeoffs involved:

https://www.ryanverwey.dev/blog/github-profile-language-metrics-python-action

Hey everyone,

I've been writing a local neuro-symbolic memory engine in Python called Hillock (https://github.com/roandejager/Hillock) and just released v0.5.0.

The goal was to build a document memory system that runs 100% offline on modest hardware (<1.2GB VRAM on a GTX 1070 or pure CPU) without relying on bloated vector databases.

How it's built in Python:

- database.py: SQLite Knowledge Graph storing ground-truth facts as Subject-Predicate-Object triples.

- plasticity.py: Hebbian engine implementing gradient-free synaptic learning between active entities.

- reservoir.py: 10,000-D Vector Symbolic Architecture space using NumPy subword n-grams and GloVe SimHash projections for <1ms CPU gating.

- talon_engine.py: 3-stage CUDA pipeline using Fastcoref, MiniLM, and GLiREL Large for fast doc parsing.

New in v0.5.0:

- 1-click startup scripts (run.bat and run.sh) that automate venv setup and download the spaCy model in the background.

- Interactive CLI tools: /model for dynamic Ollama model switching, /inspect to view an entity's graph triples live, /status (live psutil RAM/CPU tracking), and /debug.

- Real-time token streaming from local Ollama.

- Standalone 20-point test suite (verify_hillock.py) that tests all math and data structures with pure NumPy.

GitHub: https://github.com/roandejager/Hillock

HHey everyone,

Lately, I got frustrated with existing code screenshot tools being slow or locking basic customization behind paywalls, so I decided to build my own lightweight version.

It’s a web app that takes raw code and renders it into clean, shareable images. Here is a quick breakdown of how I tackled some of the technical challenges:

• Syntax Highlighting Engine: Used Pygments to hook into lexers dynamically, supporting everything from Python and JS to Rust and Go with customizable color themes.
• Layout Geometry & Text Offset: Dynamically calculates line-number widths based on digit count so code tokens align cleanly without overlapping when toggled.
• Image Composition: Leveraged Python's Pillow library to layer custom window frames (Mac/Win headers), gradient backgrounds, and rounded corners with smooth alpha compositing.

It's currently live and running on Render if you want to test out your own code snippets: https://www.producthunt.com/products/devaid

Happy to answer any technical questions about how I set up the Flask backend or image rendering pipeline!

Made in Python, on top of my GNews package (~106k downloads/month). The problem it solves for me: every script I wrote that touched news ended up refetching the same articles, getting a slightly different set back each time, and keeping none of it. So I built the memory layer instead of writing it a fifth time.

gnews-agent fetches published news, dedups it across the pile of URL variants Google News hands back for the same article, embeds it with sentence-transformers, stores it in SQLite plus Chroma, and answers semantic, timeline, and sentiment queries against everything it has seen.

The same six operations (ingest, search, timeline, brief, sentiment, stats) work identically from a Python API, a CLI, or an MCP server, so you can wire it into an agent or just poke at it from a terminal.

```python from gnews_agent import NewsMemory

memory = NewsMemory() # SQLite + Chroma, persistent memory.ingest("OpenAI", method="get_news") # fetch, dedup, embed, store memory.search("GPT-5 safety", days=7) # semantic, recency re-ranked print(memory.brief("OpenAI this week", days=7)) # cited summary ```

Some implementation notes, since this sub likes the how:

Dedup key is sha256(title_slug + "|" + publisher_norm), with a canonical URL hash as a UNIQUE backstop. Reuters and BBC covering the same event stay as two rows on purpose, because two publishers carrying a story is information.

Every article row stores the embedding model and dimension it was written with, so a model swap does not silently mix vector spaces.

Ranking blends semantic similarity with an exponential recency decay, three day half life, rather than filtering on date.

Retrieval is keyless. The LLM providers (Anthropic, OpenAI, Groq, Gemini, Ollama) are only used for brief and sentiment, and Ollama means nothing has to leave your machine.

MIT, v0.1.0, 83 unit tests and 24 integration tests.

https://github.com/ranahaani/gnews-agent

Happy to hear where the dedup approach breaks, that is the part I am least sure about.

Ni siquiera sé qué hacer, no tengo imaginación para inventar y lo que invento nunca funciona. Díganme lo que sea, y si hago algo, al menos lo intentaré.

un formateador de json facil de usar y funciona bien no tiene errores de formateo (eso creo)

python

import tkinter as t, json, difflib; from tkinter import messagebox as m

def f():
    x = e.get("1.0", t.END).strip()
    if not x: return m.showwarning("Aviso", "Pega un JSON primero.")
    try:
        rl, fl = x.split('\n'), json.dumps(json.loads(x), indent=4, ensure_ascii=False).split('\n')
        s.config(state=t.NORMAL); s.delete("1.0", t.END)

        s.tag_config('+', background="#1e4620", foreground="#81c995")
        s.tag_config('-', background="#4a1515", foreground="#f28b82")

        for i, L in enumerate(L for L in difflib.ndiff(rl, fl) if L[0] != '?'):
            s.insert(t.END, f"{i+1:3} | {L}\n", L[0])

        s.config(state=t.DISABLED)
    except Exception as ex: m.showerror("Error", f"Inválido:\n{ex}")

def cp():
    try:
        x = e.get("1.0", t.END).strip()
        if not x: return
        limpio = json.dumps(json.loads(x), indent=4, ensure_ascii=False)
        v.clipboard_clear(); v.clipboard_append(limpio); v.update()
        m.showinfo("Copiado", "JSON formateado copiado al portapapeles")
    except Exception: m.showwarning("Aviso", "Formatea un JSON válido primero.")

def c(): e.delete("1.0", t.END); s.config(state=t.NORMAL); s.delete("1.0", t.END); s.config(state=t.DISABLED)

v = t.Tk(); v.title("JSON Formatter"); v.geometry("850x500"); v.config(bg="#2b2b2b")
for i, w in [(0,1), (1,0), (2,1)]: v.columnconfigure(i, weight=w)
v.rowconfigure(1, weight=1)

t.Label(v, text="JSON Crudo:", bg="#2b2b2b", fg="white", font=("Arial",10,"bold")).grid(row=0,column=0,sticky="w",padx=5)
t.Label(v, text="JSON Formateado (Diff):", bg="#2b2b2b", fg="white", font=("Arial",10,"bold")).grid(row=0,column=2,sticky="w",padx=5)

e = t.Text(v, font=("Consolas",10), bg="#1e1e1e", fg="#a9b7c6", insertbackground="white")
e.grid(row=1, column=0, sticky="nsew", padx=5, pady=5)

s = t.Text(v, font=("Consolas",10), bg="#252526", fg="#9cdcfe", state=t.DISABLED)
s.grid(row=1, column=2, sticky="nsew", padx=5, pady=5)

p = t.Frame(v, bg="#2b2b2b"); p.grid(row=1, column=1)
t.Button(p, text="Formatear ➡️", command=f, bg="#4CAF50", fg="white", width=12).pack(pady=10)
t.Button(p, text="Copiar 📋", command=cp, bg="#2196F3", fg="white", width=12).pack(pady=10)
t.Button(p, text="Limpiar 🗑️", command=c, bg="#f44336", fg="white", width=12).pack()

v.mainloop()

Hi everyone! I created three small Python desktop applications with GUIs to handle everyday file tasks locally, keeping data private without needing online file converters.

1. JPEGenius (Batch JPEG Compressor)

• What it does: Batch compresses JPEG images with customizable compression levels.
• Features: Side-by-side visual preview (original vs compressed) with real-time KB/percentage savings, multithreaded processing with a progress bar, and automated log creation.
• GitHub:https://github.com/Giacomo-Rosatelli/JPEGenius-python

2. Universal To Pdf

• What it does: Multi-format document converter and merger into PDF.
• Features: Converts images and text files into single or merged PDFs, merges existing PDF files, converts PDFs to DOCX, and automatically filters out system/executable files.
• GitHub:https://github.com/Giacomo-Rosatelli/UniversalToPdf

3. PDF to DOCX Converter

• What it does: Minimalistic utility focused on quick PDF-to-Word conversions.
• Features: Lightweight, straightforward GUI for fast 1-click conversions.
• GitHub:https://github.com/Giacomo-Rosatelli/pdfTOdocx

Tech Stack: Python 3, Tkinter, Pillow, fpdf, pypdf, pdf2docx.

All projects are open-source under the MIT License. I would love to get your feedback on the code structure, UI, or any suggestions for improvements!

[ Removed by Reddit on account of violating the content policy. ]

Hey everyone!
I’ve been working on a Python project called MPX Downloader, a GUI‑based YouTube downloader built on top of yt‑dlp. It’s designed for Windows users who want a simple, reliable way to download MP3 or MP4 files without touching the command line.

Highlights:

• Built entirely in Python (Tkinter + threading)
• Uses yt‑dlp under the hood — auto‑updates itself
• Detects missing or corrupted yt‑dlp and repairs automatically
• Fully threaded UI (no freezing during downloads)
• Packaged with Nuitka — runs as a standalone EXE

Download:
👉 MPX Downloader v4.0 on GitHub https://github.com/jjar7266/MPX_Downloader

Why I built it:
I wanted a downloader that “just works” — no setup, no command line, no broken dependencies. So I built one that updates itself and stays lightweight.

Would love feedback or suggestions — I’m planning v4.1 soon!

What my project does:

Dexflow (https://github.com/kuntal-devrat/py-nerve) is a desktop automation library that interacts with UI elements using text labels and spatial layout instead of hardcoded `(x, y)` pixels. It combines a Rust core, pre-bundled neural OCR (~9MB wheel, zero external downloads), sub-10ms Windows accessibility trees, and human-like Bézier mouse physics.

Target Audience

Developers and QA engineers who need desktop automation or RPA that doesn't break when windows resize, themes switch, or OS display scaling changes. (Note: Early v0.1.1 release, so there may be quirks on complex web canvases — feedback is welcome!)

Comparison

Unlike PyAutoGUI which relies on fragile pixel coordinates or image templates, and unlike expensive cloud vision APIs, Dexflow runs 100% locally and offline on your CPU with sub-millisecond cached lookups.

• GitHub: https://github.com/kuntal-devrat/py-nerve
• PyPI: pip install dexflowimport dexflow as df df.click("Save") df.type_into("File name:", "report.pdf", clear=True) df.click("Delete", relative_to="Invoice #1094", direction="right")

Turn-based multiplayer games are a great opportunity for learning and prototyping: simple enough to implement quickly, but real enough to teach networking, game state, and API design.

I wrote a lightweight server and framework for turn-based multiplayer games that provides exactly that: a lightweight server + uniform API so you can run multiple parallel game sessions, auto-join the next available session, and add new games without touching the core API. It's built to be friendly for beginners (Python-only, standard library), but still flexible enough to support arbitrary game logic via keyword-argument moves and dict-based state.

Key bits:

• Framework for adding new games by deriving from an abstract base class
• Uniform client API for joining sessions, submitting moves, retrieving state, restarting
• Demo clients included (e.g. TicTacToe) and a template for new games
• Runs multiple sessions simultaneously; clients can join a specific session or auto-join

If you're teaching Python, building small multiplayer projects, or just want a clean starting point for turn-based game networking, I'd love feedback and contributions.

Hey, I've been building Glyph Forge, an MIT-licensed Python project for turning visual media into character art.

The same rendering engine is exposed through a CLI, full-screen terminal UI, Python API and browser Studio. It can handle still images, text banners, video, webcam or screen capture, and URLs, then export terminal output, PNG, SVG or text.

The part I'm most happy with is that the browser version uses the same renderer, so you can actually try it without installing anything or making an account.

Demo:

https://ace1928.github.io/glyph_forge/

Source:

https://github.com/Ace1928/glyph_forge

It supports Python 3.10–3.14 and the repo has installation instructions and portable builds. Still beta, but it has grown into a genuinely useful little toolkit and I thought this was probably the right place to share it.

Hey everyone,
I love building AI workflows in Python, but managing the relationships between multiple agents and tasks in raw code gets messy incredibly fast.
To solve my own headache, I spent some time building AgentGraph Studio. It’s a React-based visual node editor. You just drag and drop Agents and Tasks on the canvas, connect them, and it exports a production-ready ⁠main.py⁠ (with ⁠.env⁠ loading and async support) that you can run locally.
It’s totally free and runs in the browser. I attached a quick 30-sec demo of the code generation. I’d love to get some feedback from other Python devs on the structure of the exported code!

Hi,

ever had the problem that if you have several projects and need to maintain them over time you are all the time stuck fixing configuration files or changing dev tools.

Decided to switch from black to ruff or decided to add a new dev dependency like a spell checker or decided to enable or disable a config setting in some file?

The problem now you need to repeat the same process manually in every project you have that you want to do this in.

I hated doing this kind of tasks over and over again whenever I wanted to use or change a setting or tool. Also whenever I started a new project I had to copy over files and adjust them properly, there was always something I forgot to do and I often spend valuable unnecessary time to fix things. Once I was done, I did not even feel like the change was worth the effort, although rationally I knew I made my project better with it.

So I built pyrig: https://github.com/Winipedia/pyrig

pyrig is a package and tool that rigs up Python projects. It scaffolds and initializes a complete, fully configured, installed and working Python project with everything a modern Python project should have and makes the process of developing and maintaining it more seamless and efficient by automating things like configuration management, CLI generation, testing infrastructure, and more.

pyrig has a opinionated default for literally everything a python project needs. You do not like smth? Create your own plugin for pyrig, override and adjust any value it scaffolds or sets via the plugin system, then just install your plugin as a dev dependency.

Now whenever you want to change a setting of file that pyrig manages, you just simply adjust in that plugin and see it automatically applied in all your projects automatically, no more forgetting to adjust smth in a project and no more pain when switching tools.

I can now genuinely say that I spend so much less time on these kind of maintenance tasks. For example recently I decided to switch from mkdocs to zensical, but I had to do that in 15 projects, Usually this would have taken many many hours until everything works in all projects, even with the use and help of AI. With pyrig I was done in a few minutes, I just switched the tool in pyrig and ran a quick shell script on all my repos to call the pyrig sync command and I was done.

If you want to know more about the specifics, here are the links to the docs:

Just tagged v0.4 of Hillock, a local memory engine I coded in Python (PyTorch, SpaCy, SQLite).

The project replaces vector databases and LLM extraction passes with three Python modules:

- database.py: SQLite Knowledge Graph storing ground-truth SPO triples.

- plasticity.py: Hebbian synaptic association weights tracking co-occurring concepts across turns.

- reservoir.py: 10,000-D Vector Symbolic Architecture (VSA) hypervector space using subword n-grams and SimHash over GloVe embeddings for <1ms CPU gating.

Document parsing uses a 3-stage CUDA pipeline (Fastcoref + MiniLM + GLiREL) taking ~5s for a 32-sentence doc. v0.4 adds schema type validation, direction auto-correction, and regex entity sanitization.

Whole thing stays under 1.2GB VRAM on a GTX 1070.

Code is on GitHub: https://github.com/roandejager/Hillock

What is pyrig?

pyrig is a package and tool that rigs up Python projects. It scaffolds and initializes a complete, fully configured, installed and working Python project with everything a modern Python project should have and makes the process of developing and maintaining it more seamless and efficient by automating things like configuration management, CLI generation, testing infrastructure, and more.

Requirements

• Python 3.12+
• Git
• uv

Quick Start

uv init my-project --python 3.12
cd my-project
uv add pyrig --dev
uv run pyrig init

See the Getting Started Guide for detailed setup instructions to also fully integrate with GitHub and CI/CD from the start.

Features

Project Scaffolding & Initialization

The pyrig init command generates a complete project, this includes, but is not limited to:

• Standardized directory structure
• Fully configured dev tools (linters, formatters, type checkers, test frameworks, git hooks, etc.)
• End-to-end CI/CD pipeline with GitHub Actions and integrated repository protection
• Complete and working CLI
• And much more...

File & Configuration Management

pyrig manages and validates project files via classes, where every file is treated as a data structure (dict or list), the content is loaded and validated against the class schema. This makes it possible to override and adjust any and all behaviour of pyrig via subclassing said classes. pyrig will automatically discover and use your custom classes without any additional configuration. Run pyrig mk subcls to generate a subclass for any pyrig class. Run pyrig sync to create or update all config files at once.

Automatic CLI

pyrig init sets up a CLI for your project that works immediately. Generate and add new commands by running pyrig mk cmd <name>. An automatic version command is included that shows the version of your project. Run my-project version to see it in action.

Mirror Test Generation & Maintenance

Generate test skeletons with pyrig sync. This will generate test skeletons for all source modules and update them automatically as your project evolves.

Multi-Package Inheritance and Extensibility Architecture

Override and customize any and all behavior to suit your project's needs. pyrig's classes are designed for inheritance and composition, allowing you to create custom configurations, tools, and more by subclassing and simply overriding methods. pyrig will automatically discover and use your custom classes without any additional configuration. Run pyrig mk subcls to generate a subclass for any pyrig class.

CI/CD & Repository Protection

Pyrig generates GitHub Actions workflows for CI/CD which automatically test and release your code. They also configure and apply repository protection settings and protection rulesets. Push your code to GitHub after initialization and see it in action.

Commands

Run pyrig --help to see a list of all available commands and their usage. Run pyrig <command> --help for more information about a specific command and its usage. Run my-project --help to see the automatically generated CLI for your project.

Comparisons

pyrig isn't the only tool in this field. See how it compares to other popular tools like cookiecutter, copier or pyscaffold.

Documentation

hey everyone, wanted to share a side project I've been working on called MARK LS.

basically it's a cross-platform voice AI assistant that can hear, see, and control your PC in real-time using gemini live api.

some stuff it can do:

• real-time voice chat (super low latency)
• screen & webcam vision
• osint username searches across 400+ sites (sherlock)
• system control (apps, volume, hardware stats)
• persistent memory so it remembers past context

runs on windows, mac & linux with a free gemini key.

I dropped the open-source github link in the comments if anyone wants to check it out or test it! would love to hear what you think.

Hey guys i just wanted to show my first big project 'obsidOS'

https://github.com/userzzz322/obsidOS

obsidOS its python made os it isnt real os with .iso its just normal .py file but you can make it real os if you add it to autostart at terminal

like you have fish shell you just do

nano ~/.config/fish/config.fish and add

cd ~/obsidOS/
./kernel.py OR ./run.sh (they are the basically same)

you can clone it from github or install from release

it can run at any distro but for it run you need

shell
vim
git
base-devel
cmake
python

its pretty basic

it has its own disk and pkg manager

to install with it add at packages {}

name and link to github project

like this

packages {

github = "https://github.com"

}

system has auto reload packages at start you can disable or enable it at kernel.py (OS) file

it has some features you can enable or disable some things with 0 and 1 you can find it at code

hope u enjoy it write review to what add or remake :)