Hi everyone! I'm sharing SeqShow, an independent MIT-licensed browser tool for presenting Mermaid sequence diagrams one interaction at a time.

It is meant for technical walkthroughs: keep the complete diagram in place, choose a path, and explain each message or Note at your own pace.


Try it: Interactive tour · Editor · Source and usage guide

What it does

• Previous/Next and automatic playback without changing the diagram layout.
• Focus highlights the current interaction and related participants.
• Top-level alt/else selectors choose the presentation path. Only that path contributes playback steps; other cases remain muted as context. Conditions are labels, not evaluated expressions.
• Export creates one interactive HTML file that opens offline. Recipients can play, go back, toggle Focus, and change paths without installing anything or running a server.

Try your own diagram

1. Open the editor and paste the contents of a Mermaid sequenceDiagram block, without the surrounding Markdown fences.
2. Click Render.
3. Choose an alt/else path, then use Next or Play.
4. Click Export HTML to download the offline presentation.

There is no signup or AI API requirement. Diagram processing stays in your browser. The tour uses a six-service checkout flow with payment success/recovery and fulfillment choices.

Current scope

SeqShow supports a restricted sequence-diagram subset: participants/actors and aliases, messages, self-calls, Notes, and top-level alt/else. Loops, parallel blocks, activation, nested alternatives, and other diagram types are not supported yet. Unsupported input produces diagnostics rather than silently dropping statements.

Editor drafts do not survive a refresh, so keep your Mermaid source separately. The exported HTML is a presentation, not a source backup.

I'd welcome feedback from Mermaid users who explain systems to teammates: which missing construct would prevent you from using this with a real diagram, and would the offline interactive file be useful after a walkthrough?

I've been working on an open-source project called Yellow Olive for quite some time now. The original idea was to make learning Kubernetes more engaging through a retro-style terminal game built using Python and Textual.

The current implementation focuses on hands-on challenges, where users solve Kubernetes problems against real clusters, with their solutions validated automatically.

Lately, I've been thinking about taking the gamification aspect a step further.

What if learning Kubernetes felt a little more like playing Pokémon?

Instead of navigating through menus and selecting challenges, imagine exploring a world, interacting with NPCs, entering buildings, and learning concepts like Pods, Deployments, and Services through quests and storylines.

I've been experimenting with Pyxel, a retro game engine for Python, to explore this direction.

The new implementation is largely AI-assisted ( used Devin ) to build an initial proof of concept. At this stage, my intention isn't to replace the existing implementation, but to experiment with the idea and gauge community interest before committing substantial development effort.

I've attached a short gameplay recording to demonstrate what the current prototype looks like.

If there's enough interest and the feedback is encouraging, I'd like to take this forward more seriously, particularly around the game mechanics, visual consistency, and integration with real Kubernetes challenges.

For now, the existing Textual-based implementation remains the primary version of Yellow Olive.

I'm curious what fellow Pythonistas feel on this - Is it interesting enough to actually use, or does it feel like overengineering the learning experience?

The project is open source. Feedback, suggestions, and contributions are welcome. And if you find the project interesting, consider leaving a ⭐ on GitHub!

GitHub: https://github.com/Anubhav9/Yellow-Olive

Hi everyone,

I have a client requirement to create an inventory of files across approximately 100 construction projects. Each project contains documents such as contracts, drawings, RFIs, change orders, schedules, payment records, photographs, and estimating files. Some files are stored inside ZIP archives, including nested ZIP files.

The client needs a solution that can:

Scan project folders and preserve original file paths and project associations.

Inspect ZIP files and nested archives.

Use SHA-256 hashes to identify exact duplicate files and list all their locations.

Distinguish exact duplicates from potentially different file versions.

Generate standardized inventory reports, duplicate reports, and a list of files that could not be processed.
Be reused across multiple projects.

The files may be stored in Google Drive, Microsoft OneDrive/SharePoint, local folders, or a cloud server. Read-only access will be provided.

**My questions are:**
Is it possible to build a tool that meets all these requirements using Python?

If yes, how would you approach building it, and what technologies or libraries would you recommend?

Can it handle approximately 100 projects, including large files and nested ZIP archives?

Can this be delivered as a simple application that users can run, rather than requiring them to execute Python commands manually?

What would be a realistic development timeline for this solution?

I would appreciate guidance on whether this is feasible and how best to implement it.

Thanks!

i want to create python+ Django + React project as a new learning member, can anyone suggest me some project that i can do

Hey everyone!

I've been working on an open-source Python project called Stepfork, and I wanted to share it with the community.

GitHub: https://github.com/utsab345/stepfork

While building AI agents, I kept running into the same problem: an agent fails, I fix the issue, but reproducing the original failure is difficult because LLM responses and tool outputs can change between runs.

So I built Stepfork to make those failures reproducible.

What it does:

• Records instrumented LLM responses and tool calls.
• Saves executions locally as .sftrace bundles.
• Replays the recorded responses without making those instrumented external calls again.
• Compares agent behavior before and after a fix.
• Exports pytest regression tests to catch the same failure in the future.

Install:

pip install --pre stepfork

The repository includes three offline demos covering a missed order notification, an incorrect flight booking, and a wrongly denied refund.

It's still an early alpha. Replay only freezes instrumented boundaries, and native framework integrations are not available yet.

The project is Apache-2.0 licensed, and I'm actively improving it.

I'd love to hear what other developers think, especially those building AI agents. If you spot a bug, have an idea for an integration, or want to contribute, feel free to open an issue or PR.

GitHub Issues: https://github.com/utsab345/stepfork/issues

Thanks for checking it out!

An exercise to help build the right mental model for Python data. - Solution - Explanation - More exercises

The “Solution” link uses memory_graph to visualize execution and reveals what’s actually happening.

​

Hey everyone,

I have a good grasp of FastAPI and backend basics, and I want to build a portfolio project that combines FastAPI + AI.

I really want to avoid building a basic "OpenAI wrapper" (like a simple chatbot UI). I want a project idea that will actually strengthen my FastAPI skills and look impressive on a backend resume.

What are the best, practical AI project ideas that force me to use core backend concepts like:

Async processing / streaming

Background tasks

Databases or vector storage

Would love to hear your suggestions on what hiring managers actually want to see! Thanks.

🏔️ Garhwali is now accessible to technology.

A language survives through its people — but its future increasingly depends on whether it can also exist in the digital world.

I have developed and published a Garhwali Language Python Library, creating a technical foundation through which Garhwali can be programmatically accessed, processed, converted and incorporated into digital platforms.

🐍 Garhwali Python Language Library

📦 PyPI: Garhwali Python Library

💻 Open-source repository: Garhwali Language Library on GitHub

This means Garhwali can now become part of the development ecosystem — opening possibilities for local-language websites, applications, educational platforms, digital content, language tools, NLP systems, AI applications, voice technologies and other technology built for the Garhwal region.

The objective was not simply to create another software package.

It was to create a digital foundation for the language.

For years, technology has largely been developed around languages that already have digital resources, datasets, libraries and computational tools. Regional languages often remain outside that ecosystem.

Building these foundations is one way of changing that.

Garhwali should not only be spoken in our homes, villages and communities. It should also be readable, processable and usable by technology.

This library is an initial step toward making that possible.

From here, developers, researchers, students, institutions and local innovators can build upon the foundation to create technology for Garhwal, in Garhwali and around the needs of the local community.

The goal is not just to preserve a language.
The goal is to make the language usable in the future.

— Akshat Singh Bisht
Author & Developer, Garhwali Language Python Library

#Garhwali #GarhwaliLanguage #Garhwal #Uttarakhand #Python #PyPI #GitHub #LanguageTechnology #NLP #AI #ArtificialIntelligence #IndianLanguages #DigitalIndia #DigitalPreservation #OpenSource #Technology

Hey everyone, I wanted to share a Python project called Hillock that I have been building over the past several months. The goal was to give local models persistent document memory without relying on heavy vector databases or external cloud APIs.

The whole pipeline is built in Python. Instead of using a slow generative LLM to parse text into chunks, it wires up fastcoref and GLiREL to extract facts into subject predicate object triples in seconds. Storage is handled by standard SQLite with write ahead logging and Hebbian weights to link related concepts over time. Before calling the generative model, it runs hyperdimensional computing vector math to verify if the database actually has the required facts.

In the latest release, I implemented bit packed SIMD hypervectors using numpy uint64 arrays, so the CPU gating checks run in under 0.01 milliseconds. The entire engine runs locally in under 1.2 GB of VRAM or on pure CPU. It just landed on PyPI via pip install hillock, and we put up interactive documentation.

Repo: https://github.com/roandejager/Hillock
Docs: https://hillock.mintlify.site/
Discord: https://discord.com/invite/BGUPNBcVdp

Hey everyone!

Over the last few weeks, I’ve been working really hard on a project called BoardLens. It is a cross-platform hardware detection utility written completely in Python using Tkinter for a clean, modern dark-mode GUI.

I wanted to build something that could accurately grab system specs no matter what OS a person is running. To make it work, I had to dive deep into platform-specific commands. It runs:

* Windows: Custom PowerShell CimInstance queries

* macOS: Native parsing of `system_profiler` logs

* Linux: Processing `/proc/cpuinfo`, `/proc/meminfo`, and automated `lsblk` blocks

Some technical challenges I had to solve:

1. Multi-threading: Running hardware scans on the main thread was freezing my Tkinter GUI, so I migrated the scanner to a background thread using Python’s `threading` library so the UI stays responsive.

2. Packaging: I managed to compile it into a native `.exe` for Windows, a `.dmg` for macOS (which I built on my upgraded 2011 MacBook Pro!), and I'm currently setting up a native `.deb` package for Debian/Ubuntu distributions.

Right now, Linux can be run directly from source (working on Debian & Ubuntu for now).

How to run from source on Linux:

1. Download the source code from my repository's Releases page.

2. Open your terminal and navigate to the extracted folder.

3. Run the command: `python3` `main.py` (make sure Python 3 is installed on your system!)

The project is completely free and open-source. I would absolutely love it if you could check out the repository, run it on your own hardware, and let me know if it detects your components correctly! If you find any bugs or edge cases, please drop them in the comments or open an issue.

Check out the project here: GitHub - https://github.com/CodeAnd-Copper/BoardLens

Check out my YouTube Channel: https://www.youtube.com/@CodeAndcopper1

Thank you so much for reading and for any feedback

If you want to check it out, here is the Steam page:
https://store.steampowered.com/app/5349900/Mystic_Fog_Maze/

# I built a lightweight PC Performance Monitor in Python

Hey everyone! 👋

I'm Dhyey Patel, a first-year CSE student, and I recently built a lightweight PC Performance Monitor using Python.

The goal was to create a simple tool that lets me keep an eye on my system performance without making it unnecessarily heavy.

### Current features

* 📊 CPU usage monitoring

* 🧠 RAM usage monitoring

* 💾 Storage information

* ⚡ System performance statistics

* 🖥️ Hardware/system information

* 🔄 Real-time updates

* 🪶 Lightweight interface

I built this as a learning project to understand system monitoring, hardware information, real-time data, and how software interacts with the underlying system.

🔗 GitHub: https://github.com/dhyey45/PC-Performance-Monitor

I'm planning to continue improving it, so I'd really appreciate feedback from more experienced Python developers.

What would you add or change in a project like this?