r/PythonProjects2

A while back I posted a rough v1.0.0 of Kairo here. It was a Bubble Tea TUI task manager with SQLite, Git sync, and a few Lua hooks. The response was better than I expected, so I kept going.

v1.1.0 is out today, and it's the first release I'd call architecturally honest.

---

What changed (the real stuff, not marketing)

The core problem with v1.0.x was that the TUI, the Lua engine, and whatever automation you tried to do via scripts were all talking to the database through different paths. Race conditions waiting to happen, and any Lua plugin that tried to create a task was basically just hoping for the best.

In 1.1.0, everything — the TUI, Lua, and a new kairo api CLI — goes through a single TaskService layer. One source of truth. It's boring infrastructure work but it means plugins and automation scripts now behave identically to what you do from the keyboard.

---

The automation API

kairo api list --tag work
kairo api create --title "Finish report" --priority 1
kairo api update --id <id> --status done
kairo api --json '{"action": "create", "payload": {"title": "Deploy prod", "tags": ["infra"]}}'

Full JSON interface if you want to pipe it into scripts or CI. This was the #1 requested feature from the last thread and honestly I should've built it from day one.

---

Lua plugins are actually usable now

Before, event hooks were fragile — the engine wasn't wired into the task lifecycle properly so task_create events would sometimes not fire, especially on rapid creates. That's fixed.

You now get: task_create, task_update, task_delete, app_start, app_stop. Plugins can register commands that show up in the command palette, and they can call the full CRUD API from Lua. The sample plugins in /plugins actually demonstrate real patterns now instead of being hello-world stubs.

---

The background bleed fix (this one annoyed me for months)

If you used Kairo on anything other than a pure black terminal, you'd see the terminal's default background color show through in whitespace — header gaps, between tabs, row padding, all of it. It looked like a checkerboard of your theme and whatever your terminal defaulted to.

Root cause: Lip Gloss renders ANSI reset codes when a style doesn't have .Background() set. Those resets cleared the container background and let the terminal color through. Also, inline spacer strings (strings.Repeat(" ", N)) were plain text with no escape codes at all.

The fix was surgical: explicit .Background(t.Bg) on every content-level style, and wrapping all spacer strings in styled renders. Tested across resize, scroll, theme switching, all modes. It holds.

---

View shortcuts got cleaner

1–9 now switch to the corresponding tab by index, and it works for plugin-provided views too, not just built-ins. f specifically jumps to Tag View and opens the filter modal directly — saves a couple of keystrokes if you live in filtered views.

---

Stack, if you're curious: Go, Bubble Tea, Lip Gloss, SQLite (pure Go, WAL mode), GopherLua, optional Git sync.

Data lives locally. No accounts, no cloud, no telemetry. MIT licensed.

Repo: github.com/programmersd21/kairo
Releases: v1.1.0 on GitHub

Happy to answer questions about the architecture or the Bubble Tea rendering stuff — the background fill problem specifically was surprisingly deep once I traced it through Lip Gloss's render pipeline.

Hey everyone! 👋

I've been working on psp (Python Scaffolding Projects), a blazing fast, open source command line utility to scaffold your Python project. Thought I'd share it with the community!

What is PSP?

psp is simple, fast, effective, declarative, and supports Python and the entire ecosystem of tools written for it. Rather than replacing it, psp seeks to integrate and provide a useful scaffold for the end user.

psp asks only what you need. By configuring a few environment variables, you can automate any project; in seconds, not hours.

Why PSP?

⚡️ 1-100x faster compared to other scaffolding tools

🛠️ pyproject.toml support

🤝 Python 3.14 compatibility

🗃 Scaffolding file and folder structures for your Python project

🗂️ Unit-test and pytest support

🧪 Create a virtual environment

🔧 Automagically dependencies installation

🪛 Add build and deploy dependencies to distribute the package

📏 tox configuration supports and remotes CI like CircleCI, TravisCI, Gitlab CI/CD and Github actions

⌨️ MkDocs and Sphinx documentation support

🧰 Initialize git repository and gitignore file

🌎 GitHub and Gitlab remote repository support

📑 Create README, LICENSE, CONTRIBUTING, CODE_OF_CONDUCT and CHANGES files

🐳 Create Dockerfile and Containerfile for your project

💡 Can use quick, simple and full argument for rapid configuration

💾 Create $HOME/.psp.env and $PWD/.env files with your customizations

🎛️ Can use some PSP_ variables to control your defaults

📦 Support pip, conda and uv package manager

🧮 Support hatch, maturin and poetry builder

🍿 Stop, pause and resume project creation when you want; see Update

Community-friendly — Actively developed and open to contributions

Get started:

Repository: https://github.com/MatteoGuadrini/psp

Documentation: https://psp.readthedocs.io/

Check out the docs and examples to dive in

I'm actively maintaining this and welcome feedback, bug reports, and contributions from the community.

Whether you're interested in systems programming, DevOps tooling, or just exploring what's possible with Python, I'd love to hear your thoughts!

Happy coding and projects creation! 🐍

Hey everyone,

I’m a 14-year-old self-taught dev from Sri Lanka. Between school and exams, I don’t have much time to code, so I hate wasting the first 20 minutes of every project just creating folders, initializing Git, and setting up the same old .gitignore and README files.

I built project-creator to handle all the "boring stuff" for me.

What it does:

• Generates a clean folder structure instantly.
• Initializes a local Git repository.
• The best part: It automatically handles the initial commit and pushes everything to GitHub for me, so I can just start writing the actual logic right away
• Installable via pip install prj-creator --upgrade

Has an GUI and CLI version releases. Will really help if people used it and post some photos, it will make me really happy. Also please star the repository if you can. Thanks for reading all this. Bye!

GitHub Repo- https://github.com/DevX-Dragon/project-creator

I'm kinda new to Python and my requirements are always a mess. When I tried using pip my requirements would be full with bloat and I do not like that at all.

So I made a small CLI tool that watches what your Python script actually imports at runtime and generates a requirements.txt based on what it finds!

I made it so it doesn't include sub-dependencies like all of the flask ones :).

It is mainly made for beginner developers like myself, to make your requirements,txt better.

Would love feedback or ideas 🙏

GitHub: https://github.com/itsF4LCON/REQHOUND

I made it in 2 weeks in python and customtkinter it setups ffmpeg in first setup Github Release: download Source code: Link it my first project please rate it from 1 to 10

Hi fellas, I know that there are many applications out there that allow you to post on different social media platforms using one app. However, I wanted to build something that is self-hosted and private. So let me introduce to you- Prism!

Prism is a lightweight, self-hosted web application that provides a single, unified interface to broadcast your thoughts across multiple decentralized social media platforms simultaneously.

Currently, Prism supports simultaneous posting to Bluesky and Mastodon.

Backend: Python + Fastapi + Uvicorn

Frontend: HTML + CSS

Note: Frontend is the part that is AI-generated (as I do not know HTML and CSS that much).

Check it out: https://github.com/cmodi306/prism-app

I just shipped ArchUnitPython, a library that lets you enforce architectural rules in Python projects through automated tests.

The problem it solves: as codebases grow, architecture erodes. Someone imports the database layer from the presentation layer, circular dependencies creep in, naming conventions drift. Code review catches some of it, but not all, and definitely not consistently.

This problem has always existed but is more important than ever in Claude Code, Codex times. LLMs break architectural rules all the time.

So I built a library where you define your architecture rules as tests. Two quick examples:

# No circular dependencies in services
rule = project_files("src/").in_folder("**/services/**").should().have_no_cycles()
assert_passes(rule)

# Presentation layer must not depend on database layer
rule = project_files("src/")
          .in_folder("**/presentation/**")
          .should_not()
          .depend_on_files()
          .in_folder("**/database/**")
assert_passes(rule)

This will run in pytest, unittest, or whatever you use, and therefore be automatically in your CI/CD. If a commit violates the architecture rules your team has decided, the CI will fail.

Hint: this is exactly what the famous ArchUnit Java library does, just for Python - I took inspiration for the name is of course.

Let me quickly address why this over linters or generic code analysis?

Linters catch style issues. This catches structural violations — wrong dependency directions, layering breaches, naming convention drift. It's the difference between "this line looks wrong" and "this module shouldn't talk to that module."

Some key features:

• Dependency direction enforcement & circular dependency detection
• Naming convention checks (glob + regex)
• Code metrics: LCOM cohesion, abstractness, instability, distance from main sequence
• PlantUML diagram validation — ensure code matches your architecture diagrams
• Custom rules & metrics
• Zero runtime dependencies, uses only Python's ast module
• Python 3.10+

Very curious what you think! https://github.com/LukasNiessen/ArchUnitPython

A beginner friendly wrapper around os, shuthil and subprocess calls.

run "pip install shho" to install

or "pip install --upgrade shho" to update

check out repo:
https://github.com/mewannacode-egg/SHHO

After getting frustrated with task managers that either demand a subscription, require a network connection, or simply get in the way of doing actual work, I spent the past few months building Kairo — a terminal-native task manager written in Go.

What it does:

• Full task engine with titles, Markdown descriptions, tags, priorities, deadlines, and statuses
• Multiple built-in views: Inbox, Today, Upcoming, Tag, and Priority
• A ranked fuzzy command palette (ctrl+p) for tasks, commands, and tags — think VS Code's command menu, in your terminal
• Offline-first SQLite storage with WAL for reliability
• Git-backed sync: each task serializes to its own JSON file, committed automatically — no proprietary backend, no vendor lock-in
• Lua plugin system with hot-reload for custom commands and views
• JSON and Markdown import/export
• Runtime theme switching with user-definable overrides

Why I built it this way:

Most TUI task tools I found were either too minimal (basically glorified to-do lists) or tried to replicate a GUI app in a terminal, which defeats the purpose. Kairo is designed around the keyboard, not the mouse. Everything is reachable without lifting your hands off the home row.

The Git sync approach is something I haven't seen done this way elsewhere. Instead of building a sync server or relying on a third-party service, it leverages Git's existing merge and conflict-resolution infrastructure. Your tasks live in a repo you control.

The Lua plugin API is intentional too — it keeps the core lean while letting power users extend views and commands without a recompile.

Tech stack: Go, Bubble Tea, Lip Gloss, SQLite (modernc.org/sqlite, pure Go, no CGO required), Gopher-Lua.

Repo: https://github.com/programmersd21/kairo

Would genuinely appreciate feedback — especially on the plugin API design and whether the Git sync approach makes sense to people outside my own workflow. Happy to answer questions.

Hi everyone, I'm building a Python framework to decouple the application from the language, infrastructure and platform. I wanted to get some feedback. github https://github.com/SottoMonte/template , Can anyone give me some feedback on the project?

Hey guys I made a project which you can use to display your chess.com or lichess.org profile on any of your sites. I first inteded to make this for github readmes. But since it is a fully self contained SVG, you can practically embed it anywhere. It has a handful of themes for you to choose from, displays live stats and also has an optional footer with the platform logo.

Let me know if you like :D I would love to hear from you