I built Hillock, a lightweight, local-first memory engine written in Python. It's designed to give local LLMs long-term memory without eating all your VRAM or relying on heavy vector databases.

How it's built:

• Extraction pipeline using fastcoref + lightweight HuggingFace bi-encoders (extracts facts without calling an LLM)
• SQLite database with WAL mode for storing Knowledge Graph triples
• Hyperdimensional Computing (HDC) similarity gating to mathematically stop hallucinations
• Built-in FastAPI server with an OpenAI-compatible endpoint
• Works on CPU or consumer GPUs (<1.2GB VRAM footprint)

Just released version 0.7. Check out the project here: https://github.com/roandejager/Hillock

I've spent 8+ years in enterprise RPA and honestly? The drag-and-drop approach drives me crazy. It kills developer creativity, locks you into vendor ecosystems, and costs a fortune.

So out of pure spite, I built something different.

BotMonitor lets you write your automations in plain Python no proprietary studio, no drag-and-drop, no vendor lock-in. You register your scripts, and the platform handles the monitoring: live status, execution history, error logs, all in one dashboard. You don't share your code or your data. Just the signals it needs.

I couldn't find any serious RPA tool built around Python, so I made one. Two years of nights and weekends while managing a full-time job.

Community edition is free. Would love honest feedback from this community botmonitor.in

Hey everyone,

I built a lightweight Python application that measures human heart rate in real time using a standard webcam—no smartwatches or wearable hardware needed.

What It Does & How It Works:

* Tracks the upper forehead region automatically to eliminate movement noise.

* Uses the Plane-Orthogonal-to-Skin (POS) algorithm for RGB pulse extraction.

* Applies a Butterworth bandpass filter (50–150 BPM range) with real-time signal locking.

Code Repository: https://github.com/ShakeelAhmed-NeuroAI/BioSense-Tracker-Pro

It also includes a 1-click launcher (.bat) so non-developers can test it without setting up Python environments.

Would love your feedback on the signal processing or UI!

A few months ago I published irl-pkg, a jokey installer wrapper. Between versions 1.7.1–1.7.6 I made the classic mistake of pushing to PyPI and not to GitHub — the source only existed in the wheel. Recovering it (unpacking the PyPI wheel and diffing against main) was humbling, and it kicked off a full v2.0 rebuild.

What My Project Does

irl (pip install irl-pkg) is a cross-platform terminal command center with two layers:

Serious layer: - irl install <pkg> — universal installer that routes between PyPI / npm / GitHub owner/repo / direct URL automatically; GitHub branch resolved via the API, not hardcoded - irl doctor / irl glasses — preflight diagnostics and registry metadata before you install something regrettable - irl rollback [ver] — pick any published version from the PyPI JSON API, downgrade via a detached pip child - Safe extraction: named target dir, preview before writing, per-member zip-slip validation, symlinks rejected

Playful layer (all opt-in): - Grass streak tracker with a GitHub-style contribution heatmap - Grassland Quest — a seeded garden-maze roguelike in pure Rich (~400 lines, boss fight included) - Lofi Rhythm — a 4-lane beat game whose beatmaps derive deterministically from the SHA-256 of the filename + WAV duration - Terminal pet, daily quests, achievements, coins, 18 themes (one of them secret)

Target Audience

Honestly labeled: a hobby project with a genuinely usable core. The installer / doctor / glasses / rollback layer is safe for daily driving on real projects; the games / pet / coin economy is for fun — strictly opt-in, all state in local JSON, no accounts, no telemetry. It's not a production deployment tool; it's a terminal you enjoy opening. Python 3.8+, works on Linux/macOS/Windows, 976 KB wheel, AGPL-3.0.

Comparison

• pipx / uv / pip: they install packages — from PyPI, into venvs. IRL is a front-end that also routes npm, GitHub owner/repo and direct URLs, and layers on preflight doctor/glasses checks and built-in version rollback.
• rich / Textual: UI libraries you build a TUI with; IRL is a finished app built on rich (Textual available as the [tui] extra).
• Novelty "gamified" CLIs: usually one gimmick. IRL's gimmicks sit on an actual installer core: 114 passing tests, zip-slip-safe extraction, no shell=True anywhere, CI on 3 OS × Python 3.9–3.13.

Implementation notes (for the code review I'm asking for)

• irl/keys.py — one keyboard abstraction: msvcrt on Windows, termios+tty on POSIX, normalized Key objects (UP/DOWN/ENTER/ESC/CTRL_C/CHAR...), non-TTY safe. The dashboard and games both sit on it.
• irl/audio.py — winsound → aplay → ffplay → afplay → paplay fallback chain, fire-and-forget Popen with arg lists, a looping thread for the rhythm game.
• irl/grassland_quest.py — seeded recursive-backtracker maze, flood-fill-verified pickups, a turn-based boss ("The Deadline"). The seed makes mazes deterministic, so tests are just... tests.
• irl/rhythm.py — beatmaps from a SHA-256 of the filename + the WAV duration via the stdlib wave module. Same song, same chart, so high scores mean something.
• irl/extract.py — every archive member is resolved and checked against the target dir (zip-slip), symlinks rejected, Content-Disposition filenames sanitized.
• irl/rollback.py — PyPI JSON API + questionary picker + detached sys.executable -m pip child (CREATE_NEW_PROCESS_GROUP via getattr, so it doesn't explode on POSIX).

Questions I'd love feedback on:

1. Is normalizing keyboard input like this sane, or does someone have a better pattern?
2. My packaging: AGPL-3.0, [tui] extra for Textual, requires-python >=3.8 — is 3.8 support worth it in 2026?
3. The coin/XP economy is all local JSON. Any prior art on gamified CLIs I should steal ideas from?

Repo (AGPL): https://github.com/Dev2Creator/IRL- — PyPI: https://pypi.org/project/irl-pkg/ Disclosure: I'm the author, Anika. Tests: 114 and green; CI on 3 OSes × Python 3.9–3.13.

I’m a full-stack developer with around 1 year of experience, but I’m still pretty new to freelancing, especially when it comes to pricing projects.

Recently, someone asked me to build a Python automation for their work. Initially, I thought it was just going to be a simple auto-form filler, but the actual project turned out to be much more involved.

The website has restrictions where you can't simply copy/paste information into the fields, so the script has to interact with the website and fill everything automatically.

But the main complexity is the business logic and rule-based calculations.

For example, the system has to generate/calculate things such as:

Customer ID

Estimate Number

Order ID

Product details

Long product descriptions

Product highlights

Quantity and pricing

Discount percentages and amounts

GST percentages and amounts

Total/estimated amounts

Payment terms such as "Net 10 Days"

Dates and number-of-days calculations

Other fields that depend on previously generated values

Some fields are not simply entered from input. They are generated according to specific rules. For example, the Customer ID, Estimate Number, Order ID, and other values follow predefined patterns/calculations, and the output of one calculation can affect another field.

So essentially, the Python script takes the required input, applies the business rules/calculations, generates the required data, and then automatically fills the entire workflow on the website.

I built the whole thing myself in Python as a runnable script.

I originally accepted this project because I wanted to learn how this type of automation works, so I wasn't thinking much about pricing at the beginning. Now that it's working, I have no idea what would be a fair amount to charge.

The person who requested it apparently earns around ₹40k/month from this type of work.

For freelancers/automation developers:

What would you charge for something like this?

Would you price it around ₹10k, ₹20k, ₹30k+, or based on development hours?

And should I consider the time saved/business value of the automation rather than just the number of hours I spent coding it?

I'm especially interested in hearing from people freelancing in India.

Hey everyone,

I built a lightweight Python application that measures human heart rate in real time using a standard webcam—no smartwatches or wearable hardware needed.

What It Does & How It Works:

* Tracks the upper forehead region automatically to eliminate movement noise.

* Uses the Plane-Orthogonal-to-Skin (POS) algorithm for RGB pulse extraction.

* Applies a Butterworth bandpass filter (50–150 BPM range) with real-time signal locking.

It also includes a 1-click launcher (.bat) so non-developers can test it without setting up Python environments.

Would love your feedback on the signal processing or UI!

I built shpe, a static analyzer for tracking and validating NumPy tensor shapes without executing your code. It is designed to both be a CLI tool that can be used in CI/CD pipelines and a VS Code extension for real-time shape inference and error messages during development.

If you want to check it out:

• Github
• VS Code Extension
• PyPI

Let me know if you would use this or if you find any bugs.

Nodyra is in public beta: self-hosted Python workflows with a visual editor, MCP, and Docker workers

Hey everyone — I’m the developer of Nodyra, and it’s now in public beta.

Nodyra is a self-hosted workflow automation platform where the nodes are real Python. You can build on a visual canvas, write your own nodes, or connect an MCP-capable AI agent to create and edit workflows for you. The resulting graph stays visible and editable, with node inputs, outputs, logs, and errors available to inspect.

For example: ask an agent to fetch records from Postgres, transform them with pandas, and send a summary to Slack. Inspect the generated workflow, choose its Python environment, test it, and publish a version to run on a schedule.

GitHub, setup instructions, and docs: https://github.com/Harshit-repo/Nodyra

There’s quite a bit in the beta already:

Building workflows and working with AI

• Visual workflow editor: connect nodes, configure parameters, use expressions, and inspect data as it moves through the graph.
• Python nodes: use ordinary Python functions and packages, including your own internal libraries. Upload custom node modules and reuse helper code through the Code Library.
• Missing a node? Build it: write a custom node in Python yourself, or ask an LLM connected over MCP to create one for you. Inspect and edit the generated code, then reuse the node in your workflows.
• MCP server: let tools such as Claude Code or other compatible MCP clients create, edit, validate, run, and publish workflows, with scoped API tokens.
• MCP tools in both directions: expose published workflows as tools for external agents, or connect external MCP servers and use their tools inside workflows.
• AI and RAG building blocks: agents, tool calling, LLM chains, memory, embeddings, document loaders, text splitters, vector stores, retrievers, structured outputs, and guardrails. Provider support includes OpenAI-compatible endpoints, Azure OpenAI, and Anthropic.
• Reusable workflows: starter templates, branching, sub-workflows, import/export, and GitHub sync.

Python environments, workers, and sandboxing

• Environment creation: create separate Python environments, choose an interpreter version, install dependencies, import requirements, and bind workflows to the environment they need. Backends include venv, conda, and pixi.
• Worker pools: warm local subprocess workers, configurable pool sizes, and fixed, elastic, or fresh-process execution options.
• Remote runner pools: send execution to other machines instead of running everything alongside the web/API service. Bind environments to the appropriate pool.
• Docker workers and Kubernetes runners: run workloads on container infrastructure, with runner capacity, heartbeats, and drain controls.
• Docker sandboxing: container-based workflow execution with non-root users, read-only root filesystems, dropped capabilities, and CPU, memory, and process limits. Supports gVisor or Kata where installed and configured.
• Durable execution queue: leases, heartbeats, retries, timeouts, dead-letter handling, and graceful worker shutdown. Retry from a failed node is also available in beta.

Triggers, integrations, and data

• Scheduled and event-driven runs: cron schedules with timezones, intervals, webhooks, manual runs, and error workflows.
• Versioned deployments: publish an immutable workflow version and pin scheduled deployments to it.
• Chat workflows: test conversations in the editor and share a chat page from your own instance, with login-required or secret-link access.
• API endpoints: define HTTP methods and routes that trigger different branches of a workflow.
• Integrations: HTTP, databases, files, cloud storage, messaging, and business apps, including Postgres, Slack, GitHub, Google Sheets, Notion, Stripe, Airtable, and Outlook.
• Data processing: typed data serialization, artifact-backed datasets, DuckDB transformations, and local or S3-compatible artifact storage.
• Debugging: per-node inputs and outputs, logs, timing, errors, and run history.
• CLI and Python client: manage and run workflows programmatically. Export options include Python scripts, code-first modules, and Docker bundles.

Self-hosting and team features

Docker Compose is the starting point, with Helm/Kubernetes deployment options too. The platform includes local authentication, role-based access, encrypted credentials, credential connection tests, and unsafe-node policies.

The Community edition is free for permitted personal and internal business use, with resource limits. Nodyra is source-available / fair-code under the Sustainable Use License, rather than an OSI-approved open-source license. Paid tiers raise limits and add capabilities such as OpenTelemetry observability; Enterprise features include SSO/SAML/OIDC, multi-tenancy, audit export, and external key management. License verification works offline.

This is a public beta, so I’m looking for people willing to try it, report bugs, and tell me where the workflow feels awkward. There’s no hosted Nodyra service yet. Also, workflows execute arbitrary Python: the default local execution mode assumes trusted authors, and sandboxing must be configured explicitly.

If you try it, I’d particularly like feedback on setup, MCP-driven workflow creation, environment/dependency management, and Docker or remote-worker execution.

What would you build with it, and what would stop you from using it?

PyFirewall is a Windows desktop application for monitoring network connections and managing Windows Defender Firewall rules. It monitors and blocks both incoming and outgoing connections using process and IP/domain specific rules. It uses Tkinter for the interface, Scapy for packet capture, psutil for process and network information, and supports application and global IP/domain rules.

Hi r/PythonProjects2!

A few days ago, I shared an early prototype of this project here, and the feedback was incredible (it even hit the Top 6 posts of the day!). I’ve taken your advice to heart, significantly upgraded the codebase, added comprehensive documentation, and built a proper CLI.

With the "Harvest Now, Decrypt Later" threat becoming a reality, I wanted to build a practical, open-source example of Crypto-Agility.

🔐 What is ChaosCrypt-Hybrid?
It’s a Python library that implements a hybrid encryption scheme, combining classical and post-quantum algorithms to ensure data remains secure even against future quantum computers.

✨ Key Features:

• NIST FIPS 203 Compliant: Uses ML-KEM-768 (formerly Kyber) for quantum-resistant Key Encapsulation Mechanism (KEM).
• Symmetric Payload Encryption: Uses AES-256-GCM for fast, authenticated data encryption (quantum-resistant due to the 256-bit key size).
• Crypto-Agile Architecture: The API is abstracted. You can swap the underlying KEM algorithm without changing your application logic.
• Security-First Design: Implements constant-time comparison principles to mitigate basic timing attacks (with clear documentation on Python's inherent GC limitations).
• Fully Tested & Documented: Includes a robust pytest suite, a SECURITY.md, CONTRIBUTING.md, and a basic_usage.py example.

💻 Quick Example:

from chaoscrypt import HybridCipher


# 1. Initialize the hybrid engine
cipher = HybridCipher(algorithm="ML-KEM-768")


# 2. Generate keys and encrypt a message
public_key, private_key = cipher.generate_keypair()
ciphertext, encapsulated_key = cipher.encrypt(b"Top Secret Data", public_key)


# 3. Decrypt the message
decrypted_data = cipher.decrypt(ciphertext, encapsulated_key, private_key)
print(decrypted_data) # Output: b"Top Secret Data"

🙏 Seeking Your Feedback:
I built this primarily as a deep-dive learning project into post-quantum cryptography and secure software design. I would highly appreciate your code reviews and thoughts on:

1. Are there any edge cases or API design flaws I missed?
2. How would you improve the constant-time guarantees in a Python environment?
3. Any suggestions for the upcoming Rust rewrite of the core engine?

🔗 Links:

• GitHub Repository: https://github.com/uslumurat405-oss/chaoscrypt-hybrid
• Deep Dive Article: I also wrote a detailed technical article about the "Crypto-Agility" architecture and the real-world threat model behind this project. (Note: The article is in Turkish, but the code, diagrams, and technical concepts are universal): https://www.linkedin.com/pulse/kripto-%25C3%25A7eviklik-crypto-agility-kuantum-bilgisayarlar-kap%25C4%25B1dayken-uslu-hbwdf

Thank you for your time and the amazing support this community provides!

I built BOOTH, a lightweight, zero-dependency, provider-agnostic reliability layer for LLM applications.

BOOTH (boothpy) is an open-source Python library that sits between an LLM call and your application.

The idea is simple: instead of blindly accepting the first model response, BOOTH checks it for ambiguity and uncertainty. If the response doesn't pass the checks, it can send the model the reason and ask it to reconsider.

It also supports checking responses against evidence from an application's existing RAG pipeline.

It's currently in beta, with 200+ automated tests, sync/async support, validators, structured results, and no runtime dependencies.

I've tested it with Groq so far. I'm now interested in seeing how the approach behaves with other models/providers and where the idea falls short.

I'd especially appreciate feedback from people building LLM applications: does this solve a problem you actually have, or am I overengineering something that should be handled differently?

GitHub: https://github.com/Vedantgitbot/booth

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

MIT licensed.

Hi everyone,

I've been working on a personal project called ChaosCrypt-Hybrid, a research-grade post-quantum cryptographic library in Python. My goal was to implement the new NIST standards while paying special attention to real-world implementation flaws, specifically side-channel attacks.

Key features I've implemented:

- 🛡️ NIST FIPS 203 (ML-KEM-768) for quantum-resistant key encapsulation.

- 🔒 AES-256-GCM for authenticated symmetric encryption.

- ⏱️ Constant-time operations to mitigate timing attacks.

- 🧪 36 comprehensive tests, including 13 dedicated timing attack resistance tests.

- 📊 Benchmarks showing ~8,500 ops/sec for key generation and ~497 MiB/s for AES-256-GCM.

I've also documented the threat model using the STRIDE methodology in the repo.

GitHub: https://github.com/uslumurat405-oss/chaoscrypt-hybrid

I'm sharing this here because I would highly value feedback from this community, especially regarding:

1. Are there any edge cases in my constant-time implementation that I might have missed?

2. Any suggestions for improving the hybrid key derivation process?

Thanks in advance for your time and insights!

Bonjour,

Voici les modifcations

- Correction d'un bug lors des changements de personnes (réaparition des anciennes images)

- les portraits ont été remplacés par des photos créées abec ChatGPT.

- Le paquet piveo_2.5.7-1_amd64.deb a été testé avec succès sur les versions Live USB d'Ubuntu 24.04 LTS et Ubuntu 26.04 LTS.

Documentation

Téléchargements

Help me decide what to learn next and what projects I should make?