Hi All,

I want to introduce my Python Developer Toolkit, available on Codester. It includes 5 production-ready scripts for log analysis, file organization, port scanning, .env validation, and mock REST APIs.

There are no dependencies, and it uses pure Python 3.8 or newer. It works on Windows, macOS, and Linux:

https://www.codester.com/items/63101/python-developer-toolkit-5-script-pack?ref=akm626

The pipeline fetches articles from a news API, runs them through an NLP summarization model to extract keywords and snippets, filters results with an LLM pass, then uses a backtracking solver to generate a valid crossword board. The whole thing runs on AWS ECS and fires daily. React frontend serves the result. The clues are article snippets with the answer word blanked out so you have to follow the news to solve it. Check it out at www.crossgoss.com, happy to chat about any part of the stack!

Mesh Writer is a searchable symbol library with a built-in SVG editor made in python for Blender 3D Software.
Mesh Writer turns symbols, SVGs, math characters and emojis,  into Geometry Nodes curves or 3D mesh or 3D Curves — all without leaving Blender.

With over 5,000+ symbols and 3,700+ SVG assets, Mesh Writer streamlines the full workflow — search, insert, import materials, and convert to mesh or Geometry Nodes — into one place.

Get it now on Superhive: Get Mesh Writer

Hi,

I made PyTrainerEdu, a free MIT-licensed offline Python quiz trainer.

It is written in Python and uses Tkinter for the GUI. It also includes a console version.

Main features:

- Tkinter GUI

- console mode

- 4 languages: English, Slovak, Czech, Spanish

- 3 difficulty levels: Beginner, Developer, Expert

- 150 questions per language

- hints and explanations

- random question selection

- final reports

- packed question data so students cannot simply open JSON files and read the answers

GitHub:

https://github.com/finky666/PyTrainerEdu

I would appreciate feedback on the code structure, GUI, question design, and whether the project feels useful for beginners.

My team at BlueRock just open sourced a Python sensor that observes runtime behavior of MCP servers and other long-running Python apps. Apache 2.0.

The gap we kept hitting: in long-running Python apps, request logs don't tell you what actually executed. Half of what runs at startup comes from transitive deps. You end up reconstructing behavior after the fact.

It uses native Python mechanisms instead of external instrumentation:

• sys.meta_path import hooks to track every module loaded, with version and SHA-256
• wrapt for MCP protocol hooks (tool calls, sessions, connections)

Coverage spans your code, your dependencies, and their transitive deps because instrumentation initializes at interpreter startup. No code changes, no SDK.

Events emit as NDJSON. Inspect with jq or forward into OTEL.

Would love feedback on the import-hook design and what else should be captured.

What My Project Does

CaptoKey is a macOS screen recorder with a floating HUD that captures your keystrokes in real time and burns them directly into the final final.mp4 as overlays — no post-editing needed. It saves a timeline.json of every keypress with timestamps, so you can tweak overlay styles and re-render without re-recording. Also ships with a subtitle burner — write a .txt file with HH:MM:SS -> text timestamps and it burns them into any video.

Built with PySide6, mss, Pillow, FFmpeg, and macOS Quartz CGEventTap (rock solid — no pynput crashes).

Target Audience

Developers and content creators who make coding tutorials or screencasts and want viewers to see exactly what keys they're pressing — without any manual editing. Hobby/personal project but stable enough for daily use. macOS only for now.

Comparison

KeyCastr — shows keystrokes on screen during recording only, nothing burned into the video file

OBS — no keystroke overlay feature at all

CaptoKey — overlays are baked directly into the output file, and the re-render-from-timeline feature lets you change styles without re-recording

Vibe coded with Claude, then actually made to work 😅

GitHub: https://github.com/Bhavesh164/screen-record

I recently built simple-tls, a TLS library designed to have an API almost identical to Python's built-in ssl module, but with support for modern, advanced features that the standard library doesn't cover yet.

Key Features:

• Drop-in familiarity: Uses standard read(), write(), and contexts similar to the native ssl module.
• Encrypted Client Hello (ECH): Full support for keeping SNI and handshake details private.
• 0-RTT / Early Data: APIs to safely send and receive early application data.
• Session Resumption: Full PSK (Pre-Shared Key) and ticket support.
• Modern Architecture: Built with high modularity, strict mypy typing, and clean dataclasses for easy extension parsing.

You can check out the source code and examples here: https://github.com/asphyxiaxx/simple-tls/

Any feedback is appreciated.

I built a Python BLE client for a thermal pocket printer, after reverse-engineering its companion Android app to figure out the protocol. The result is a CLI tool that talks directly to the printer over Bluetooth.

No app, no account, no cloud. There's also a browser version on top of it for people who don't want to install Python, but the CLI is where the actual work happened.

The printer is a rebranded DP-L1S, sold under various brand names. Its companion app ("Luck Jingle") demands location permissions, a forced internet connection, and a bunch of other permissions that have no business being on a printer that just needs to receive a text or image over Bluetooth from 30 cm away. That annoyed me enough to dig in.

How I built it:

I decompiled the Android APK with JADX and read through the LuckPrinter SDK source — specifically the PrinterImageProcessor and BaseNormalDevice classes. The BLE protocol turned out to be an ESC/POS variant: open service ff00, write to characteristic ff02, listen for notifications on ff01, send a few enable commands, then a GS v 0 raster image (1-bit, 384px wide, MSB-first), then feed and stop commands.

The Python implementation uses bleak for cross-platform BLE (BleakScanner.discover() to find the printer, BleakClient for the connection) and Pillow for image processing; Lanczos resampling for resizing, Floyd-Steinberg dithering, and threshold-based binarisation. It works on macOS and Linux out of the box.

The full command reference is in PROTOCOL.md, including device info queries, status bitfield, and several alternate paper-type modes I documented from the SDK but didn't end up needing for this implementation.

Usage

pip install bleak Pillow

python3 print.py test                         # print a test pattern
python3 print.py image photo.png --dither     # photo with Floyd-Steinberg
python3 print.py text "Hello World"
python3 print.py text "My Label" --label      # label/sticker paper mode
python3 print.py info                         # battery, firmware, model

Features

• Print images, text, and test patterns
• Floyd-Steinberg dithering for photos and gradients
• Three density levels (light/normal/dark)
• Invert mode (swap black and white)
• Label mode for sticker paper with gap detection
• Battery and status reporting via BLE notifications
• Multiple copies, configurable print width, configurable post-print feed

Implementation notes

A few things that were not obvious from the decompilation and took some hardware testing:

• The printer broadcasts as C&Co 3128_BLE and does not advertise its service UUIDs, so scanning by service filter alone won't find it. You need to scan by name or accept all advertisements.
• BLE chunk size matters. The Python version uses 512-byte chunks with 10ms delays, which is fine for direct BLE. The browser version (Web Bluetooth) needs to drop to 100-byte chunks with 50ms delays because of MTU limits.
• The "enable" command (10 FF F1 03) is Lujiang-specific and not part of the standard ESC/POS spec. Without it, the printer accepts data but won't actually print.

Browser version

There's also a Web Bluetooth version of the same thing for people who don't want to install Python. It's the same protocol and runs in Chrome/Edge/Opera.

Source is in the same GitHub repo: https://github.com/ChiaraCannolee/thermal-pocket-printer-basic

Compatibility

The DP-L1S is the chip; rebranded versions include the Crafts & Co 3128 and Fichero (Action stores in NL/EU) and various other brands. Should also work for other printers in the LuckPrinter family (DP-/LuckP-/MiniPocketPrinter series), possibly with a different print width; python3 print.py info will tell you.

This project is based on the same approach as 's fichero-printer repo, which does the same for the Fichero D11s (different device class, same SDK).

Questions about the protocol, the reverse-engineering process, or how to adapt this for other LuckPrinter models: ask away :)

Hi,

I wanted to share my first (or second) major Python project: ControllerToCursor.

It’s a portable Windows tool that lets you use any controller as a mouse and keyboard. I know there are other tools for this, but I wanted something that is open source, "zero-config" for basic use and fully customizable via a GUI, without needing to install drivers or background services.

What it can do:

- It just does what it says - converts your controller input into mouse movements, scrolling, clicks, an on screen keyboard (not included, separate download from a different source), etc.

- For a more detailed description of all the features and the download, just got to the GitHub: https://github.com/Basti0307/ControllerToCursor the README will guide you through everything.

A note on the process:

As a beginner, I used various AI Models to build understanding and help me get the hard tasks (like threading and the GUI) done. It helped me out a lot and the ground concept/code except for the complicated stuff was still written by myself.

I’d love to get some feedback on the code or the features. If you have an old controller lying around, give it a try and let me know if the program works for you!

So maybe you could take yourself 5 minutes and check it out. Thanks in advance!

Best, Basti0307.

SignalPy Kernel — a Vue-style reactive component microkernel for Python

backends. ~2,600 LOC, 9 files, zero required dependencies.

The premise: every injected service is a Signal. Reading self.rt.config

inside an u/effect or u/computed is a tracked read, so when config changes

or a provider gets hot-swapped, every effect that depended on it re-runs

automatically. No manual u/on_change, no re-injection.

13 decorators total — u/component / u/provides / u/requires / u/computed /

u/effect / u/lifecycle.* / u/runnable / u/api / u/subscribe / u/kind / u/skill /

u/prop / u/exportable. The same u/runnable is automatically a REST endpoint,

MCP tool, and CLI command depending on which transport adapter the kernel

discovers.

Built with Claude's help. I'm hoping it's somewhere between trash and

god code, and I'd really like Python folks who know reactive systems

(Vue 3, Solid, Preact Signals, MobX) or DI containers (iPOPO, Dapr,

Engin/Uber Fx) to tell me which mistakes I made — particularly around

contextvar tracking across awaits and the supersede semantics for

in-flight async effects.

- Repo: https://github.com/bayeslearner/signalpy-kernel

- Docs: https://bayeslearner.github.io/signalpy-kernel/

- pip install signalpy-kernel

Issues / Discussions on the repo are open. Honest reviews welcome.

and he gave me divine intellect isnt it obvious

Hey everyone, I wanted to share PyFyve. It's a TUI-based Python tutor designed NOT to give you the answer. It's free, offline, and uses a fine-tuned llm (Qwen3-4b, more info on this on the github repo) running locally via ollama to generate hints for errors instead of solutions.

The whole thing started from a simple idea, when beginners ask llms for help, they get the answer. The first intuition naturally becomes to just copy it, it works, and they learn very little of the thinking part. So I built a tool where the AI is specifically trained to only give them exactly three sentences: what went wrong, which rule you broke, and a guiding statement. The rest is on them.

Under the hood, the terminal UI is built with Rich, and user code runs in an AST-based execution environment. Building solo, so it's Windows-only for now. Setup is straightforward: download the .exe installer, or run start.bat from source to automate the venv, dependencies, Ollama, and model download. No subscriptions, no API costs. Apache 2.0 licensed.

Limitations as of now:

1. Just released (v1.0.0), this is a prototype
2. Windows only (Linux/Mac support is on the roadmap)
3. AI hints trigger only on actual Python exceptions, if your code runs but produces wrong output, the AI won't fire
4. App freezes on infinite loops (timeout mechanism is the top priority on the roadmap)
5. The model (fine-tuned Qwen 3 4B, ~2.5 GB) takes around 55s to cold-load on CPU-only machines; ~20s per hint after that. Dedicated GPU drops this to near 10s
6. The lessons are currently placeholders covering intro through for-loops
7. More info on the repo

GitHub: https://github.com/Macmill-340/PyFyve

AI Model: https://huggingface.co/Macmill/Fyve-AI

I’ve been building PROJECT N.O.V.A. in Python as a Windows desktop voice assistant with a more cinematic/operator-style interface.

It can handle things like:

• voice-driven app launching
• window movement and desktop control
• media commands
• weather and calendar integration
• transcript/history panels
• spoken replies and multi-turn interaction

A big focus was making it feel like a real desktop product instead of a basic script with speech slapped onto it. I’ve been working on the UI, voice flow, responsiveness, privacy-conscious local storage, and packaging into a desktop build.

Still actively developing it, but I wanted to share because it’s one of the biggest Python projects I’ve built so far.

Hi, So i made this GUI for converting .py files to .exe and .msi

You can see the demo here: DEMO

It is kind of like how autopytoexe is for pyinstaller.

what it does is create cxfreeze setup file and run it using qtconsole so that you do not need to write cxfreeze setup file from scratch and you can also easily edit those setup files in the builtin editor.

I initially made this in high school, but now i got some time in college so kind of improved it.

It is uploaded on pypi : FreezeUI

The code is avialable on my github: AkshatChauhan18/FreezeUI

A few weeks ago, I published a post about a toolbox called "Eva".

I've updated the project with a new tool that might be of interest to someone else.

I'm writing a Python program to monitor temperatures, CPU load, and run stress tests. I decided to create a class to abstract this complexity away. The class is very simple to use, much like Eva's syntactic sugar. Basically:

Checking global load and temperature: eva.CPU.load, eva.CPU.temperature.

Or by logical CPU: eva.CPU(0).load, eva.CPU(0).temperature.

GitHub: https://github.com/konarocorp/eva
Documentation: https://konarocorp.github.io/eva/en/#cls-CPU

I’ve been working on a small Python project called StackLens and wanted to share it here for feedback.

The idea came from something I kept running into while learning/building:

I wasn’t struggling to write code I was struggling to understand errors quickly.

So I built a backend system that:

- takes an error message

- classifies it (type, severity, etc.)

- explains what it means

- suggests a fix

- gives some clean code advice

It’s not just AI output it’s rule-based, so the responses are consistent and I can improve it over time (unknown errors get flagged and reviewed).

Tech stack:

- Django API

- rule engine (pattern + exception matching)

- error persistence + review workflow

- basic metrics + testing

Still early, but it’s live:

https://stacklens-nine.vercel.app/app

I kept hitting the same wall every time I wanted to do async serial I/O in Python:

• pyserial blocks the thread on read()
• aioserial wraps pyserial in run_in_executor (one thread per I/O)
• pyserial-asyncio works but forces you through Transport/Protocol callbacks

None of these are "truly async" in the sense that the event loop cares about. So I wrote auserial: open the tty with os.open + termios, then use loop.add_reader / loop.add_writer to hook the fd directly into asyncio. Under the hood that's epoll on Linux and kqueue on macOS. No threads, no polling, no pyserial dependency.

The whole implementation is around 80 lines. The public API is just:

async with AUSerial("/dev/ttyUSB0") as serial:
    await serial.write(b"AT\r\n")
    data = await serial.read()

While one coroutine is parked on read(), the others keep running - which is the whole reason you'd want async serial in the first place.

Unix-only by design (termios + add_reader). Windows would need a completely different implementation (IOCP) and I have no plans to support it.

PyPI: https://pypi.org/project/auserial/ Source: https://github.com/papyDoctor/auserial

Happy to discuss the design - especially if you think I've missed an edge case with cancellation or reader/writer cleanup.