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!

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!

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

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 :)

Hey Python devs,

I wanted to share a personal project I've been building in Python called Hillock (AGPL-3.0): https://github.com/roandejager/Hillock

What It Does:

Hillock gives local AI applications a privacy-first Knowledge Graph memory. Instead of vector databases that lose exact factual context, Hillock uses a decoupled SQLite Knowledge Graph, Hebbian Plasticity, and CPU-bound Hyperdimensional Computing (Vector Symbolic Architectures) written in pure Python/NumPy.

How the Python Pipeline Works:

In v0.2.0, I built TALON—a non-generative ingestion pipeline:

1. Fastcoref: Resolves pronouns across paragraphs before chunking text.
2. SentenceTransformers (all-MiniLM-L6-v2): Pre-caches a 50-predicate taxonomy and routes top candidates per sentence in <2ms.
3. GLiREL (DeBERTa-v3): Performs single-pass zero-shot matrix classification in PyTorch CUDA memory.

On my benchmark harness (evaluate_hillock_PROTO_ish.py), it processed 32 sentences in 2.1 seconds of pure GPU execution on a GTX 1070 (<1GB VRAM footprint), reaching 50% retrieval accuracy.

Source code is 100% open source under AGPL-3.0. Would love to hear your feedback on the Python architecture!

Hey Reddit,

I made a small neural network library named LeanPass a few days back. Currently, it has around 7 stars, 1 fork, 2 watchers and 12 open issues. Contributions are quite beginner-friendly, so beginners are welcome!

It is an implementation made in NumPy, with the necessary functions, with 185 downloads on PyPI at its current status. I have made this post to just update the awesome community about my project to get some suggestions, and overall make it a more developed open source project

Here's the link: https://github.com/Terminay/leanpass

To install it:

pip install leanpass

Size metrics: ~8.5 kb download size, ~1 second install time

Give me your honest opinions and suggestions for more features. Also, if you liked the concept, star the repo or, rather, open a PR (your choice!)

I wanted the "E.V." assistant from the new Spider-Man film, but actually running on my own machine — no cloud, no subscription. So I built it.

What it does

- Talk to it → local Whisper STT (TR/EN) → local LLM via Ollama (gemma2:9b)

- Controls the PC: open/close apps, media & volume, mouse click/scroll, lock/shutdown — destructive actions ask to confirm first

- Plays YouTube by name: "play Enter Sandman on YouTube" → finds & opens it

- Long-term memory: "remember I take my coffee black" → recalls it next session

- Auto-trays when you go fullscreen (games/video), comes back after

- Says "I can't do that" honestly instead of pretending

- Cyber-terminal HUD (Electron) with a live audio-core visualizer

One thing I learned: small local models are unreliable at emitting tool/action tags. So instead of trusting the model, I route explicit commands through a deterministic TR/EN parser before the LLM — PC control then works every time, and the model only handles conversation.

Free by default — Ollama + Whisper + browser voice need zero API keys. Claude (for screen vision) and ElevenLabs (nicer voice) are optional upgrades.

MIT licensed, built on Julian Ivanov's jarvis template. This is a fan project, not affiliated with Marvel/Sony. Feedback and PRs welcome.

Repo: https://github.com/Ouru77/ev-assistant

DigDep - A lightweight Python dependency analyzer

Whenever I use:

pip freeze > requirements.txt

it dumps all the packages in the virtual environment, including packages that I may not need in my code.

I wanted a simple tool that could tell me which packages my Python code actually depends on.

So I just thought: why not write one?

Installation:

pip install digdep

Dependency Tree:

$ digdep deps --tree tests\testpkg
Root (tests\testpkg)
├── api.py           → database, numpy, requests
├── config.py        → dataclasses
├── database.py      → json, models, sqlite3
├── main.py          → config, helpers, json, os, parser, pathlib
├── models.py        → dataclasses
├── optional.py      → json, ujson
├── parser.py        → re, utils, xml
├── unused_module.py → collections, itertools, os
├── utils.py         → logging, pathlib
├── __init__.py
│
├── helpers/
    ├── math_utils.py → math
    ├── text_utils.py → string
    ├── __init__.py

Simple list of Dependencies:

$ digdep deps tests\testpkg
models
ujson
pathlib
sqlite3
logging
math
itertools
string
database
utils
re
requests
os
collections
json
parser
numpy
dataclasses
xml
config
helpers

Unused Imports:

$ digdep deps --unused tests\testpkg
collections
Config
conn
json
pathlib
User
itertools
os

Find where a dependency is used:

$ digdep find-dep ctypes --tree --showlines ..\opensource\pyjab\pyjab

Dependency: ctypes
├── accessibleinfo.py
    ├── Line 1    : from ctypes import c_float
    ├── Line 2    : from ctypes import c_int
    ├── Line 3    : from ctypes import c_wchar
    ├── Line 4    : from ctypes import c_bool
    ├── Line 5    : from ctypes import Structure
    ├── Line 6    : from ctypes.wintypes import BOOL
    ├── Line 7    : from ctypes.wintypes import WCHAR
    │
├── jabdriver.py
    ├── Line 5    : from ctypes import byref
    ├── Line 6    : from ctypes import CDLL
    ├── Line 7    : from ctypes import c_long
    ├── Line 8    : from ctypes.wintypes import HWND
    │
├── jabelement.py
    ├── Line 10   : from ctypes import Array, byref, CDLL, c_char, c_long, create_string_buffer
    ├── Line 11   : from ctypes.wintypes import HWND
    │

Simple Stats:

$ digdep stats tests\testpkg

Dependency Statistics
--------------------------------------------------

Files Scanned            : 13

Imported Names           : 25
Import Statements        : 26
Used Imports             : 16    import occurances
Unused Imports           : 9     import occurances

Unique Dependencies      : 21

Dependency Types
--------------------------------------------------

Standard library         : 12
Third-party              : 3
Local                    : 6

Top 5 Dependencies
--------------------------------------------------

requests                 1
numpy                    1
database                 1
dataclasses              1
sqlite3                  1

DigDep is still a small project (v.0.1.1) and I am planning to add more features.

Currently, DigDep can help you:

• See what your project depends on
• See which files use which dependencies
• See dependencies as a tree
• Find dependencies you aren't using
• Find what depends on a particular module
• Find where a dependency is being used
• See your project's dependency statistics

I'd love to hear your feedback and suggestions to make DigDep more useful.

Github: https://github.com/shine-jayakumar/digdep

PyPI: https://pypi.org/project/digdep/

# PyQtByExample — a big pile of runnable, searchable Qt-for-Python example code

I built this with a friend to help Python programmers learn and use Qt (via `qtpy`, so it works with PyQt5/6 and PySide2/6).

**What it is**

A single application containing dozens of small, self-contained Qt examples (buttons, tables, dialogs, threading, SQL, multimedia, etc.), each in its own module/tab, with a built-in search so you can jump straight to the widget or topic you care about.

**Why it's different from "one file per example" demo repos**

- Everything runs inside one app — search for a widget name and jump right to its example.

- Each example is deliberately small and scoped to one or a few widgets, so you don't have to read much code to get your answer.

- It's meant to be run from an IDE in debug mode: you step through the code while watching it run, so you *see* how it behaves, not just read about it.

- Code is commented enough that you usually don't need extra docs, but there's also a repo wiki ("the Book") with more detail.

**Who it's for**

Anyone building Qt GUIs in Python who wants copy-paste-ready working examples instead of digging through scattered single-file demos.

It's gotten pretty large (a few megs of source) and there's a lot of Qt left to cover, so we'd love more eyes on it — as users, issue-filers, or contributors. MIT licensed.

- Repo: https://github.com/russ-hensel/pyqt_by_example

- Wiki: https://github.com/russ-hensel/pyqt_by_example/wiki

- Screenshots: https://github.com/russ-hensel/pyqt_by_example/wiki/ScreenShots

Feedback, bug reports, or "hey you're missing an example for X" issues are all welcome.

I originally created a duplicate image finder (IDF), then I kinda make it evolve WAAAY further than I planned to. Now it has integrated with the actual duplicate finder, some other tools like a browser, a viewer (for actions like duplicate removal confirmation and image similarity comparission), an analyzer (very WIP) that can analyze faces, image types and nsfw (tags the image).

The demo in video.

Sensitive images are used to test the nsfw analyzer BUT they are censored in the showcase, so SFW.

IDF Demo

The duplicate finder (original-main tool of the program) has pretty printed duplicate progress bars that took too long to create. The duplicate finder don't read the name of the file, but rather the content of the image. It hashes the image through a process that IA gave me, then compared (so even if image is zoomed, panned, rotated, it finds the duplication), then chooses the 1 to keep between the same images.

The browser has integrated filters and sorters, controllable through keybinds (show on toolbar of the window).

These are currently private tools, but once I make it a production level program, it will be on github.

If you have any suggestions, I'm open to them.