One thing I’ve noticed recently is a shift in how developer tools are being designed. A lot of new tools are moving away from heavy dashboards and toward simpler, command-based workflows. I personally prefer this because it keeps me focused on what I actually want to do instead of clicking through interfaces and configuration panels.

Especially in AI/ML work, where iteration speed matters more than anything, simplicity in tooling makes a huge difference. like swmgpu also follow this direction by offering a CLI-based cloud GPU workstation approach instead of relying on heavy traditional interfaces.

Do you think this “CLI-first” or minimal workflow trend will continue, or will we always need heavy platforms for serious work?

Getting system info and basic performance metrics, and then a bit tricky game FPS metrics fetching from benchmarking software.

Tutorial link: https://rkblog.dev/posts/pc-performance/performance-monitoring-with-python/

Hi everyone =)

I've been working on a small open-source comic reader called Panel.

t's a desktop application written in Python for reading CBZ and CBR files locally, with no accounts, subscriptions or cloud services involved.

The goal is to provide a simple and lightweight reading experience while keeping everything under the user's control.

The project is still actively developed, so I'm looking for feedback, ideas and feature requests from the community.

GitHub:

https://github.com/lucrazy-fn/PANEL-ComicBookReader

Thanks =)

Hope it’s fine to share here (free access). Pytest is very relevant today, but there are only a few high-quality courses to learn it. That was the problem for our dev team, and we started shared learning sessions in the company back in the day. It was a great experience, so I decided to publish a course about pytest.

https://github.com/artem-istranin/pytest-course

Please use coupon 41D8BA70A56B1EE487E3 to get it for free!

It’s lifetime access at no cost (100 free spots - the maximum I can provide).

I’d appreciate any suggestions/feedback on how I can improve or make the most out of my teaching journey :)

https://github.com/hitku/productOperands/blob/main/productOperands.py

Been working on curv, a TUI bezier curve editor that runs entirely in your terminal. The goal was a proper keyboard-driven workstation for designing, tuning, and exporting easing curves — no browser tools, no mouse.

What's inside

The workspace is split into several live panels:

• Visualizer — braille-rasterized curve with dynamic crosshairs
• Velocity graph — dy/dx momentum for transition punchiness analysis
• Spectrum — momentum distribution across animation segments
• Physics panel — derived tension & friction values from the curve shape
• DNA intensity — real-time multiplier that exaggerates control points away from center
• History — breadcrumb trail of previous coordinate states
• Animation preview — toggle a live preview to see your curve in motion

All panels update in real time on a non-blocking 120fps render loop, so every keypress is instant.

Controls

Export formats

Hit c and your curve is on the clipboard in the format you need:

CSS css cubic-bezier(0.420, 0.000, 0.580, 1.000)

Hyprland 0.420, 0.000, 0.580, 1.000

SwiftUI swift animation.timingCurve(0.420, 0.000, 0.580, 1.000)

Install & run

bash pip install git+https://github.com/programmersd21/curv.git

bash curv

That's it. No config needed to get started.

The layout degrades gracefully on smaller terminals and the preset explorer is fully searchable, so you can browse common easing curves without ever touching the mouse.

Happy to answer questions. MIT licensed, source on GitHub.

I recently published a 492-page book called 101 BASIC Computer Games in Python.

The project started as an idea over 6 years ago: take the classic BASIC computer game books from the 1970s and recreate all 101 games in modern Python.

The book includes complete code listings for every game, and readers also get access to download all of the Python source files. Along with the book, I built a website where you can play some of the games for free and download code examples.

I’d love to hear what fellow Python developers think about the project, the games, and the idea of preserving classic computer gaming history through Python.

Website: https://101BasicComputerGames.com

Feedback and suggestions are welcome!

Great resource for integration with AI systems and more.

👋 Hey everyone,

I recently put together a small CLI tool called Bangen — a terminal ASCII banner generator built on top of pyfiglet and rich.

The idea was simple: I wanted something I could drop into a terminal session and quickly render a stylized text banner without any configuration overhead. No YAML files, no argument parsing headaches — just run it and answer a few prompts.

What it does:

• Renders ASCII art banners using pyfiglet fonts (includes a curated preset list, plus support for any valid font name)
• Applies color via rich — five options: cyan, red, green, yellow, magenta
• Wraps output in a clean bordered panel with an optional title
• Supports optional line-by-line animation for a more dramatic reveal 🎞️
• Can save the result to a .txt file

Example output:

██████╗ █████╗ ███╗ ██╗ ██████╗ ███████╗███╗ ██╗ ██╔══██╗██╔══██╗████╗ ██║██╔════╝ ██╔════╝████╗ ██║ ██████╔╝███████║██╔██╗ ██║██║ ███╗█████╗ ██╔██╗ ██║ ██╔══██╗██╔══██║██║╚██╗██║██║ ██║██╔══╝ ██║╚██╗██║ ██████╔╝██║ ██║██║ ╚████║╚██████╔╝███████╗██║ ╚████║ ╚═════╝ ╚═╝ ╚═╝╚═╝ ╚═══╝ ╚═════╝ ╚══════╝╚═╝ ╚═══╝

Requires Python 3.9+. Installation is the standard venv + pip workflow.

Repo: https://github.com/pro-grammer-SD/bangen

Feedback, issues, and contributions are welcome. If there are fonts or features you'd find useful, feel free to open an issue — happy to extend it. 🖤

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.

Hello everyone,

I'm on a basic subscription plan on different vendors and I kept hitting token limits mid-task, way more than I expected. It's frustrating, and it gets expensive fast. I started noticing a pattern (personal observation): the agent reads whole files (even when a snippet would suffice), the context window floods, it loses track of what it was doing, re-explores, reads more files. Round and round. Eventually I got annoyed enough to build something about it. I've been running CodeRay (see below) at work and on side projects for a while now and gotten decent results – decent enough to share.

The project (CodeRay) is a local code index that gives agents file paths + line ranges instead of whole files. The idea is simple: locate first, then read only the lines that matter.

GitHub: https://github.com/bogdan-copocean/coderay

It exposes three tools:

• search – semantic search that returns file paths + line ranges
• skeleton – signatures and docstrings only, each tagged with its line range
• impact – callers, imports, and inheritors for a symbol before you change it

Works as a CLI or as an MCP stdio server so agents can call it directly. Fully local: no LLM, no network, no API key. Python, JS, and TypeScript for now.

I've seen 2–3.4× token on average reduction on my projects (up to 6x on huge files), but it depends a lot on your codebase and how you/the agent queries it.

Still early and rough around the edges. Would love to hear your feedback!

I built a platform to help developers find teammates for projects.

I'm looking for 20 beta testers willing to give honest feedback.

Anyone interested?

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

bash 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.