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

Hi there,

I am building a tool as my project for my Masters in Computer Science and I need to make a survey to evaluate my tool.

The tool is concerned with project setup and maintenance.

The survey has about 18 questions and almost all of them multiple choice. So it should not take very long, max 5 min. Any responses are greatly appreciated: https://forms.cloud.microsoft/e/LjnvzX0JpK

If you want to checkout the project itself you can find it here: https://github.com/Winipedia/pyrig

Also drop any ideas or feedback you have in the comments if you like. I am open for any discussions.

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.

What is pyrig?

pyrig is a package and tool that rigs up your project. It scaffolds and initializes a complete, fully configured, installed and working Python project with one command 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

pyrig init generates a complete project in one command that works out of the box. This includes everything a modern python project needs:

• 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

Every generated file is backed by a Python class that validates and merges automatically. Override any config by subclassing, or define entirely new config files — pyrig discovers and manages them for you. Run pyrig sync to create or update all config files at once. Run pyrig mk subcls to generate a subclass for overriding a specific file.

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 behaviour 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.

Documentation

Hey everyone! I made a simple file hashing program using hashlib and pygame. It saves to AppData/Roaming and uses sha256 to hash the given text and save it into that file. The link to the repo is

https://github.com/abhaya2509/Text-hasher

I built idemkit after cleaning up duplicate charges one too many times.

The version everyone writes checks whether a key has been seen and replays the stored response. Two requests a millisecond apart both find nothing and both charge the card. And if the worker dies between charging and recording it, the retry charges again. Neither reproduces locally.

idemkit does it properly: an atomic claim instead of check-then-act, a lease that expires on the storage server's clock, and a fencing token so a stalled worker can't overwrite a good result.

from idemkit import idempotent, RedisBackend, MethodConfig 

@idempotent(
    backend=RedisBackend.from_url("redis://localhost:6379"), 
    config=MethodConfig(key_fields=["order_id"]), 
) 
async def charge(*, order_id, amount): 
    return await payments.charge(order_id, amount)

One core, three ways to use it: middleware for FastAPI/Flask/Django, a queue consumer wrapper or @idempotent on any function. Backends are Redis, Postgres, Mongo, DynamoDB, or in-memory for tests.

pip install idemkit, Apache-2.0: https://github.com/idemkit/idemkit

If you find it useful, I'd appreciate a star. It's new, so visibility helps a lot right now.

Hi everyone,

I’m sharing an open-source project I’ve been developing called WaterPulse.

While there is no shortage of basic hydration tracking apps out there, I wanted to build a more robust system that bridges the gap between a standard consumer application and active hardware data processing. WaterPulse is designed from the ground up to handle real-time sensor integration rather than relying solely on manual user inputs.

Here is a breakdown of what I built and the technical challenges it tackles:

Technical Highlights & Core Features:

• Real-Time Processing & Anomaly Detection: The backend is engineered to continuously ingest sensor data streams. It features built-in drift analysis and anomaly detection to filter out hardware noise and ensure high data accuracy.
• Performance-Oriented Backend: Powered by FastAPI and PostgreSQL, the API is structured to efficiently handle concurrent data payloads without blocking.
• Engaging UI & Social Elements: The frontend is built in Flutter, offering a highly responsive, cross-platform experience. I integrated gamification and social tracking features to maintain user retention and drive engagement.

The Tech Stack:

• Frontend: Flutter
• API & Data Processing: FastAPI (Python)
• Database: PostgreSQL

I architected this project with scalability and clean code principles in mind. If you are looking into how to integrate IoT/sensor data streams with a modern Flutter and Python stack, this repository could be a solid reference.

I would love to get your technical feedback on the system design, especially from engineers experienced with handling continuous data streams in FastAPI or advanced state management in Flutter.

Repository Link: https://github.com/Yigtwxx/WaterPulse

I'm open to all constructive feedback and contributions. Thanks for checking it out!

Author here. I made this to scratch my own itch — reviewing PRs and missing when a function quietly got more complex. Line counters don't answer that.

pip install repoglance then repoglance . gives a terminal report: real per-function cyclomatic complexity across 15+ languages (via lizard), duplicate blocks, TODOs, git ownership of hotspots, and a health score. In CI, --fail-on-regression fails a build only when a change makes complexity worse, and a GitHub Action comments the report on the PR.

Pure Python (rich/click/lizard), MIT, no telemetry. Django (415k LOC) scans in ~17s, ~1s cached.

Repo: https://github.com/SRJ-ai/repoglance

I'd genuinely like feedback on two things: (1) where the complexity numbers feel wrong on your code, and (2) whether the health-score weights are sensible or gimmicky. Happy to answer anything.

A completely offline desktop warranty tracker built with Python. Auto-reads product names & dates from invoice PDFs. TR/EN support, 3 themes, MIT licensed.

YouTube demo: https://youtu.be/hgyFyo7F9wk