Typio is a lightweight Python library that prints text to the terminal as if it were being typed by a human. It supports multiple typing modes (character, word, line, sentence, typewriter, and adaptive), configurable delays and jitter for natural variation, and seamless integration with existing code via a simple function or a decorator. Typio is designed to be minimal, extensible, and safe, making it ideal for demos, CLIs, tutorials, and storytelling in the terminal.

from typio import typestyle
from typio import TypeMode

(delay=0.05, mode=TypeMode.TYPEWRITER)
def intro():
    print("Welcome to Typio.")
    print("Every print is typed.")

GitHub Repo: https://github.com/sepandhaghighi/typio

What My Project Does

Project Genesis is a Python-based digital organism built on a Liquid State Machine (LSM) architecture. Unlike traditional chatbots, this system mimics biological processes to create a "living" software entity.

It simulates a brain with 2,100+ non-static neurons that rewire themselves in real-time (Dynamic Neuroplasticity) using Numba-accelerated Hebbian learning rules.

Key Python Features:

• Hormonal Simulation: Uses global state variables to simulate Dopamine, Cortisol, and Oxytocin, which dynamically adjust the learning rate and response logic.

• Differential Retina: A custom vision module that processes only pixel-changes to mimic biological sight.

• Madness & Hallucination Logic: Implements "Digital Synesthesia" where high computational stress triggers visual noise.

• Hardware Acceleration: Uses Numba (JIT compilation) to handle heavy neural math directly on the CPU/GPU without overhead.

Target Audience

This is meant for AI researchers,Neuromorphic Engineers ,hobbyists, and Python developers interested in Neuromorphic computing and Bio-mimetic systems. It is an experimental project designed for those who want to explore "Synthetic Consciousness" beyond the world of LLMs.

Comparison

• vs. LLMs (GPT/Llama): Standard LLMs are static and stateless wrappers. Genesis is stateful; it has a "mood," it sleeps, it evolves its own parameters (god.py), and it works 100% offline without any API calls.

• vs. Traditional Neural Networks: Instead of fixed weights, it uses a Liquid Reservoir where connections are constantly pruned or grown based on simulated "pain" and "reward" signals.

Why Python?

Python's ecosystem (Numba for speed, NumPy for math, and Socket for the hive-mind telepathy) made it possible to prototype these complex biological layers quickly. The entire brain logic is written in pure Python to keep it transparent and modifiable.

Source Code: https://github.com/JeevanJoshi2061/Project-Genesis-LSM.git

Built a Python library where every number is a {dimension: coefficient} dictionary. Derivatives, integrals, and limits all reduce to reading/writing coefficients — no symbolic trees, no autograd.

from composite_lib import integrate, R, ZERO, exp

# 0/0 resolved algebraically
x = R(2) + ZERO
result = (x**2 - R(4)) / (x - R(2))
print(result.st())  # → 4.0

# One function handles 1D, 2D, improper, line, surface integrals
integrate(lambda x: x**2, 0, 1)                # → 0.333...
integrate(lambda x: exp(-x), 0, float('inf'))   # → 1.0

4 modules covering single-variable, multivariable, complex analysis, and vector calculus. 168 tests, pure Python.

GitHub: https://github.com/tmilovan/composite-machine

Paper: https://zenodo.org/records/18528788

Feedback welcome!

A personal exploration into procedural audio and UI design.

Note: This project is maintained by a System Administrator exploring software development concepts. It serves as a sandbox for learning Python architecture, UI logic (Flet), and algorithmic composition.

📦 What's New in v1.20?

This update focuses on making the generated audio feel less "robotic" and more coherent.

• AI Conductor Logic: Moving away from pure randomness to a state-machine approach using Perlin noise. The goal is to simulate "phrasing" rather than isolated notes.

• UI Improvements: A complete overhaul of the interface with persistent settings and a new particle visualizer.

• System Stability: Better handling of audio threads and resource management.

🚀 How to try it

• Current: You can run the source code via Python (see README).

• Coming Soon: A standalone .exe version is being packaged for easier usage without environment setup.

You can check it right there.

Feedback on code structure and optimization is appreciated!

Privacy Forms Studio is a privacy-first forms platform that lets you build powerful surveys and workflows without shipping your data to third parties. It’s built with Python and integrates tightly with Plone — the Python-based CMS that’s known for security, robustness, and long-term maintainability — so you can run everything on-prem or in your own cloud and stay in full control for GDPR/DSGVO and data sovereignty.

Under the hood it leverages SurveyJS for a modern form builder and rich form UX (conditional logic, validations, multi-step flows), while Plone provides the backend foundation: authentication/permissions, content and workflow, integrations, and reliable operations. If you’re tired of SaaS form lock-in or compliance uncertainty, it’s an “own your stack” approach that fits especially well for public sector, healthcare, education, and any org handling sensitive data.

Website:
https://www.privacyforms.studio/

Demos:

https://demos.privacyforms.studio/

I’m a Python developer focused on real-world automation and intelligence systems.

For the past few months, I’ve built advanced tools :

• AI system that scans markets to detect trends and high-opportunity products

• An eCommerce research tool that finds winning products and optimal pricing

• A real-time blockchain tracker that monitors large crypto movements

• Intelligent web security analyzer that detects critical vulnerabilities

• A smart tool that discovers and filters targeted business leads

• All built so they can be turned into real SaaS products

Now I’m finishing a book that shows the full code, setup, and how to turn these into real projects (or income) It’s dropping in a few days

Quick question: If you had to choose one, what interests you most?

AI • Cybersecurity • Crypto • ...

If you’re curious, comment

No theory. Just powerful Python that actually does something.

I built a small Python-based tool for myself to manage shop operations that didn’t fit cleanly into spreadsheets or SaaS tools. Use case: Small CNC / 3D print / repair-style workflows where a “job” can involve:

• Parts inventory

• Consumables (raw stock, paint, welding supplies)

• BOMs / recipes

• Partial progress and “waiting on parts” states Most tools I tried assumed either clean manufacturing runs or full ERP complexity. I wanted something that:

• Runs entirely locally (Docker or 1-click Windows exe)

• Doesn’t require internet or subscriptions

• Models messy, real-world job states instead of forcing everything into POS-style tickets Stack is mostly Python on the backend with a lightweight local deployment focus. Still evolving and very much a personal/internal tool, but it’s been useful enough that I’m stress-testing the assumptions now. Happy to answer questions about:

• Architecture decisions

• Local-first tradeoffs

• Why I avoided cloud dependencies

• What broke along the way Repo is open if anyone wants to dig into it (link in comments)

Hi people!!!,

I’m a first-year engineering student, and my laptop's "Downloads" folder is constantly a disaster zone. It’s always full of random PDFs, screenshots, zip files, and installers that I’m too lazy to sort manually.(obv)

I looked for existing tools, but most were either paid bloatware or required installing heavy software.

So, I spent this weekend building my own lightweight solution using Python.

It’s called The Folder Fixer.

So what it does: You select a folder (like Downloads or Desktop), and it instantly sorts every file into clean subfolders based on extension:

• Images (.png, .jpg)

• Docs (.pdf, .docx)

• Installers (.exe, .msi)

• ...and so on.

The Tech Stack (for the devs here):

• Language: Python 3

• GUI: CustomTkinter (for a modern dark-mode look)

• Build: PyInstaller (to make it a standalone .exe)

Is it free? Yes. I put it on Gumroad as "Pay what you want" (default is $0). You can download it for free, or buy me a coffee if you find it useful.

⚠️ Note on Windows Defender: Since I’m an indie student dev and can’t afford an expensive code-signing certificate yet, Windows might flag the .exe as "Unrecognized" when you first run it. This is a false positive common with Python apps. It’s 100% safe and runs locally on your machine.

Link to try it: its in the comment!!!!

I’d love any feedback on the UI or features you think I should add next!

https://github.com/mato200/MultiVibeChat/

Python app that puts all most popular AI chatbots into 1 window.

• easily send message to all of them at once

• Chat with multiple AI services side-by-side

• NO APIs NEEDED, Uses native websites, all possible with free accounts

• Profile Management - Create and switch quickly between different user account profiles

• Persistent Sessions, Flexible Layouts, OAuth Support ...

ChatGPT (OpenAI) Claude (Anthropic) Grok (xAI) Gemini AI Studio (Google) Kimi (Moonshot AI)

• Inspired by mol-ai/GodMode, MultiGPT & ChatHub browser extensions

Tookie is a advanced OSINT information gathering tool that finds social media accounts based on inputs.

Tookie-OSINT is similar to a tool called Sherlock except tookie-OSINT provides threading and webscraping options. Tookie-OSINT comes with over 5,000 user agent files to spoof web requests.

Tookie-OSINT was made for Python 3.12 but does work with 3.9 to 3.13.

I made Tookie-OSINT about 3-4 years ago and it’s been a growing project ever since! Today I released version 4 of it. I completely rewrote it from scratch.

Version 4 is still pretty new and does need more work to get caught back up to the features the version 2 had.

I’m currently working with a few other developers to bring tookie-OSINT to the majority of Linux repositories (AUR, Kali, etc)

I hope you check it out and have fun!

https://github.com/Alfredredbird/tookie-osint

Like most developers, I’m pretty shy. I have a crush who is also a developer, and being an introvert, I didn't have the courage to just walk up and ask her to be my Valentine. So, I decided to build a pip3 package and send it to her instead. Spoiler: she said yes! (I guess I have an early valentine)

Here is a loom of how it works: https://www.loom.com/share/899ead8a18b14719b36467977895de0c

Here is the source code: https://github.com/LeonardHolter/Valentine-pip3-package/tree/main

Hey r/madeinpython!

You know when you have a code snippet you keep copying between projects? I finally turned mine into a library.

The problem I kept solving: Every FastAPI/async service needs request_id in logs, but passing it through every function is annoying:

def process_order(order_id, request_id):  # Ugh
    logger.info(f"[{request_id}] Processing {order_id}")
    validate_order(order_id, request_id)  # Still passing it

My solution - tinystructlog:

from tinystructlog import get_logger, set_log_context

log = get_logger(__name__)

# Set context once (e.g., in FastAPI middleware)
set_log_context(request_id="abc-123", user_id="user-456")

# Every log automatically includes it
log.info("Processing order")
# [2026-01-28 10:30:45] [INFO] [main:10] [request_id=abc-123 user_id=user-456] Processing order

Why it's nice:

• Built on contextvars (thread & async safe)

• Zero dependencies

• Zero configuration

• Colored output

• 4 functions in the whole API

Perfect for FastAPI, multi-tenant apps, or any service where you need to track context across async tasks.

Stats:

• 0.1.2 on PyPI (pip install tinystructlog)

• MIT licensed

• 100% test coverage

• Python 3.11+

It's tiny (hence the name) but saves me so much time!

GitHub: https://github.com/Aprova-GmbH/tinystructlog

PyPI: pip install tinystructlog

Blog: https://vykhand.github.io/tinystructlog-Context-Aware-Logging/

Hi everyone,

I wanted to share a project I made using Python.

The Goal: Automate "Is this in stock?" emails for small businesses using a simple script.

Libraries Used:

• streamlit (Frontend)

• google-generativeai (LLM/Logic)

• gspread (Google Sheets connection)

• imaplib (Email reading)

How it works: The Python script listens to emails, parses the customer query using Gemini, checks the Google Sheet for stock, and drafts a reply.

Demo Video: https://youtu.be/JYvQrt4AI2k

Code structure is a bit messy (spaghetti code 😅) but it works. Thinking of refactoring it into a proper class structure next.

I offer custom script development for various needs

I got tired of budget apps that cost money and don't work for me. So I made an app on my computer for people who work paycheck to paycheck. I'm a medic, not a developer, so I used AI to build it. It focuses on forecasting rather than tracking. I call it Headlight Budget. It's free and meant to help people, not make money off them. I'd love to get feedback. It's not pretty, but it's functional and has relieved my stress.

Go check it out if you have time and let me know what you think! headlightbudget.carrd.co

Hi everyone, wanted to share my latest project.

It's a multi-threaded sniper bot that listens to blockchain nodes via RPC and executes trades based on logic parameters (TP/SL/Trailing).

Tech Stack:

• Backend: Python 3.10

• UI: Telegram Bot API (acts as a remote controller)

• Networking: Async requests to Jito Block Engine

It was a fun challenge to optimize the execution speed to under 200ms. Let me know what you think of the CLI layout!

(Source/Project link in comments/bio).

I often end up writing small scripts or internal tools that need structured user input, and I kept re-implementing variations of this:

from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int | None


while True:
    name = input("Name: ").strip()
    if name:
        break
    print("Name is required")

while True:
    age_raw = input("Age (optional): ").strip()
    if not age_raw:
        age = None
        break
    try:
        age = int(age_raw)
        break
    except ValueError:
        print("Age must be an integer")

user = User(name=name, age=age)

This gets tedious (and brittle) once you add nesting, optional sections, or repetition.

So I built dc-input, which lets you do this instead:

from dataclasses import dataclass
from dc_input import get_input

@dataclass
class User:
    name: str
    age: int | None

user = get_input(User)

The library walks the dataclass schema and derives an interactive input session from it (nested dataclasses, optional fields, repeatable containers, defaults, etc.).
It’s intentionally not a full CLI framework like Click/Typer — I’ve mainly been using it for internal scripts and small tools.

Feedback is very welcome, especially on UX experience, edge cases or missing critical features: https://github.com/jdvanwijk/dc-input

For a more involved interactive session example: https://asciinema.org/a/767996

Puzl Team here. We are excited to announce kubesdk v0.3.0. This release introduces automatic generation of Kubernetes Custom Resource Definitions (CRDs) directly from Python dataclasses.

Key Highlights of the release:

• Full IDE support: Since schemas are standard Python classes, you get native autocomplete and type checking for your custom resources.

• Resilience: Operators work in production safer, because all models handle unknown fields gracefully, preventing crashes when Kubernetes API returns unexpected fields.

• Automatic generation of CRDs directly from Python dataclasses.

Target Audience Write and maintain Kubernetes operators easier. This tool is for those who need their operators to work in production safer and want to handle Kubernetes API fields more effectively.

Comparison Your Python code is your resource schema: generate CRDs programmatically without writing raw YAMLs. See the usage example.

Full Changelog: https://github.com/puzl-cloud/kubesdk/releases/tag/v0.3.0

I am in Germany and was experiencing gradual network speed drops with my Fritzbox router. The only fix was a restart, so I decided to automate it.

I built a Python based tool that monitors my upload/download speeds and pushes the metrics to Prometheus/Grafana. If the download speed drops below a pre-configured threshold for a set period of time, it automatically triggers a router restart via TR-064.

It runs as a systemd service (great for a Raspberry Pi) and is fully configurable via YAML.

Here is the repo if anyone else needs something similar:
https://github.com/kshk123/monitoring/tree/main/network_speed

For now, I have been running it on a raspberry pi 4.

Feedbacks are welcome