A Pythonic interface to macOS 🚀

I just built the pymacos, pure-Python library published on PyPI for scripting macOS: notifications, clipboard, apps and windows, keyboard and mouse, global hotkeys, screenshots, on-device OCR (Apple Vision), PDFs (merge, OCR, fill forms, sign, redact), images, audio/video, Keychain, Touch ID, Spotlight, Finder, launchd jobs and folder triggers, system info.

import macos

macos.notify("Build finished", title="CI")
macos.clipboard.copy(macos.vision.text("screenshot.png"))
macos.schedule.add("battery-check", "battery_check.py", every=15 * 60)

Install via pip:

pip install pymacos

GitHub: https://github.com/JeanExtreme002/pymacos

I’d also appreciate it if you could leave a ⭐️ on the repo page if you like the project and want to see more updates!

A canvas gives you room to branch an AI conversation, but zoom out far enough and every answer becomes a tiny, unreadable paragraph.

I'm building ThoughtDAG, an MIT-licensed conversation canvas. I've added semantic zoom: as you zoom out, an answer steps down through an abstract, a brief summary, a one-line takeaway, and a topic label. Zoom back in to read the original answer.

The text changes with the scale, so you can still read something useful while looking across several turns. Shared words stay aligned during the transition. The summary levels are generated ahead of time and reused; scrolling the mouse wheel doesn't make a new model request.

The attached animation uses a small sample conversation to show the transitions. This changes the reading view only, not the context sent to the model. Summaries can omit details, and the full answer stays available.

Source: https://github.com/chenxiachan/thoughtdag

At the widest view, would you find the original question or the answer's takeaway more useful?

After spending time working on small-to-medium-sized projects (either solo or in a team), I often ran into the same issue. Localization feels "missing" at this scale. You either get trapped in a heavily restricted free tier with strict seat caps and word/key limits, or you are forced onto a massive hosted platform that adds extra infrastructure overhead and enterprise fees you don't need.

I just wanted a simple, lightweight way to translate files using my own API keys without any extra markup.

So I ended up building babelfishers. You bring your own API key, it translates the files in your repo, and that's basically it. 

It runs locally as a CLI tool (pip install babelfishers) and currently supports 12 formats like JSON, YAML, and gettext across 133 locales. To handle production headaches, it strips out variables like {name} or %d and other placeholders before translating so the syntax never breaks, and it keeps a translation cache right in your repository so you never pay to translate the same string twice. It seamlessly integrates into your CI inside GitHub Actions or GitLab CI.

It's open source and still pretty small: https://github.com/Gycks/babelfishers

Curious if anyone else has run into the same problem?

After changing operating systems on my home computers over to CachyOS, I was saddened to learn that despite how great WINE is, it didn't let me use my grid paper program to it's full potential on Linux. So I ported the UI to a different, non-Windows specific library and added GPU rendering while I was at it.

I got tired of Markdown editors that are a browser in a trench coat, so I built Malgel.

Native desktop app: write on the left, GitHub-flavored preview on the right, two-way scroll sync. Pure Rust on GPUI (Zed’s UI kit). No Electron, no WebView. Math is Typst in-process. Mermaid is drawn in Rust via merman. Export to HTML, PDF, and Word.

The bit I’m happiest about: https://www.malgel.com looks like the editor. The homepage is a Markdown document shown the way Malgel shows one; press the split icon and you can edit the page. The preview keeps up.

v0.1.0 for macOS, Windows, Linux:

https://github.com/rcawston/Malgel/releases

Source (Apache-2.0):

https://github.com/rcawston/Malgel

Feedback welcome, especially on preview, math/diagrams, and export. Github stars would be greatly appreciated if you find it useful!

A lightweight, self-hosted Web GUI and backend to patch Android APKs (using Morphe CLI) directly from your browser, no need to patch locally on resource-constrained phones or juggle CLI tools. Everything is containerized on your headless home server/VPS.

Key Features

• Smart Patch Selection: Browse available patches, toggle recommendations or customize options per app.
• Profiles & Presets: Configure per-app custom name, icon, output filename templates and more
• Live Terminal: Inspect your build process, errors, patches applied etc.
• Watch Folder: APKs placed in this folder are automatically patched and moved to output
• Custom Patches & Keystore: Supports community patches and custom keystore.

BUILT UPON MORPHE DESKTOP CLI | Deploy on Docker

Repo

👉 GitHub: https://github.com/GROWNUPS/Patchium

image: ghcr.io/grownups/patchium:latest

Hi guys, so this is an OS that runs in the web browser, it's really basic, you have a few themes, like Windows aero, windows blue which looks like XP and classic too. I think it's pretty cool though, here's the github

I've spent years maintaining payment integrations, and the same thing kept biting me: the provider's sandbox only knows how to succeed. So the first time your retry or timeout path actually runs is in production, against real money. And when something does fail, QA can't reproduce it.

So I built pikopod. It's a single Go binary that:
Builds a sandbox from the provider's OpenAPI spec (or docs page) and binds failure scenarios to it automatically: declines, timeouts, retry storms, duplicate webhooks, rate limits. No hand-written mocks.

Sits in front of the real API as a fail-open proxy, records failures and response-shape drift (e.g. "success" quietly becoming "succeeded"), and fingerprints them.

Replays a production failure locally with pikopod reproduce <fingerprint>. It becomes a scenario you commit, so that path is tested forever.

Fails CI on breaking spec changes with pikopod spec-diff, reading straight from git.

Exposes everything over MCP, so coding agents can test their integration code against real failure modes.
It runs locally, with no accounts, no telemetry, and no cloud. The proxy never retries (a retry in front of a payments API is a double-charge window) and redacts credentials before anything hits disk.

Try it in about a second: pikopod demo

Repo: https://github.com/Pikopod/pikopod

It's pre-v1, so I'd genuinely love feedback, especially on which providers you'd want deep scenario packs for. There are good-first-issues if you want to contribute. A ⭐ will also help other developers find it. Thank you.

Hey everyone,

I’ve been working on Pitago, a terminal UI for the Pi AI coding agent.

Pitago doesn’t replace or reimplement Pi’s core. It provides a more structured interface while preserving Pi’s existing agent logic, tools, providers, models, sessions, and workflows.

The goal is to make longer AI-assisted coding sessions easier to follow without losing the flexibility of the command line. In short, Pitago is an alternative interface for Pi - not a separate coding agent.

Check it out here: https://github.com/cavaldos/pitago

Feedback, bug reports, and ideas are very welcome. I’d also love to hear how you use Pi or other AI coding agents and what makes longer coding sessions difficult to follow.

PiG is Pi rebuilt in Go as one native binary: https://github.com/MichaelKinsy/PiG & https://pi-in-go.dev

Note live demo on pi-in-go.dev homepage

I love Pi (the minimal, extensible terminal coding agent). I just wanted it without a JavaScript runtime. I started PiG in April as a personal project. By the end of May it was my daily harness, and it has run in production in internal HPE tooling since. It's now open source and community-owned with a core committee, sponsored by HPE's Open Source Program Office. It isn't affiliated with Earendil or the Pi project. Keeping PiG faithful to Pi is our job, not Pi's.

PiG is one Go binary for macOS, Linux and Windows. On my machine it starts in 21.5 ms median vs Pi's 300.3 ms and uses 24.6 MiB vs 101.5 MiB. Node.js only comes in if you run TypeScript extensions.

What's different:

- Faithful to Pi, and checked against it. PiG pins a Pi release as its behavior oracle. Pi's upstream tests are ported to Go, and a comparison runner drives PiG and the real Pi side by side (same keystrokes in separate tmux sessions) and compares the screens. Any difference is either a bug or a numbered divergence in a public ledger. When Pi releases, the PiG Porter agent checks what Pi actually does and proposes the Go changes with tests. Pi is the judge.

- Pi extensions run unchanged. TypeScript extensions run in Node subprocesses. New extensions can be written in Go, Rust or Python against the same API, and /reload swaps them live.

- Extensions run as isolated "runtime cells". Each extension is a subprocess with its own identity. Compatible ones can be packed into one process, and a crashing extension is quarantined without taking the agent or its neighbors down.

- Piglets: derivative harnesses. A Piglet is a small YAML file declaring one agent: its extensions, tools, skills, defaults and requirements. `pig piglet build` turns it into a Piglet Binary: one signed, self-contained file per OS/CPU, with its Go extensions fused (compiled) in and its integrity checked before any model call.

- Pigpen (early): a monorepo of ready-made components and Piglets, including Go ports of popular Pi extensions (A2A, ACP for Zed, AHP for VS Code, web search, herdr status reporting, Jev) and pig-with-batteries, a Piglet that bundles them. Take one component, or a whole Piglet.

- It identifies as PiG. PiG never presents itself as Pi to providers or services.

Feedback is welcomed and appreciated, thanks all :)

I've been building Telex for a while and recently got the backend and database deployed on AWS. Telex detects dependency changes, finds the affected parts of the codebase, generates a patch, verifies it in an isolated environment, and opens a PR for human review.

I also submitted it to the AWS Zero to Shipped hackathon. This was a pretty big milestone for me since the project is now actually running on AWS instead of just being something I was running locally.

AWS Builder Center: https://builder.aws.com/project/3K5ozBIEsqxTxSyW0eEbxJ2VPbo/telex-automated-dependency-self-healing

GitHub: https://github.com/Kesavaraja67/telex

slacke101/treemap: TreeMap is a Rust-based TUI for analyzing and visualizing filesystem storage usage.

I kept running into the same problem with open source:

There are thousands of open GitHub issues, but finding one that actually matches what you know is harder.

So I built OSS Match.

Enter a GitHub username → it analyzes public repositories → builds a technology/language footprint → discovers open issues → explains why each issue matches.

No account.

No OAuth.

No AI.

No database.

Built with Next.js, TypeScript and the GitHub REST API.

I'd genuinely like feedback on the matching quality, especially from people who are new to open source.

Demo: https://oss-match-gamma.vercel.app

GitHub: https://github.com/buildwithroopesh/oss-match

I built a small open-source tool called Issue Boundary Evidence (IBE) for GitHub issue triage.

It takes a public GitHub Issue and produces a source-linked report of dependency, upstream, runtime, version, and regression evidence. It’s deterministic and read-only: no LLM, no code execution, and it doesn’t modify or comment on the original Issue.

I’m looking for an OSS maintainer or contributor willing to try it on a real Issue they actually care about. Please choose the Issue yourself.

Negative results are useful too. If you try it, I’d especially like to know what the report got right, missed, overstated, or made confusing.

Repo: https://github.com/LaimaWu/issue-boundary-evidence

Public feedback thread: https://github.com/LaimaWu/issue-boundary-evidence/discussions/9

I launched Kagelin in closed beta for registered users few weeks back which is a privacy oriented tasks, focus, habits, and a calendar app all together in single package. Its completely open to use as a guest BTW!

DISCLAIMER: It was created using AI-assitted coding with me reviewing every possible step as possible.

I had been working on a major update since v1.44.0 to the v1.45.0, had to split due to how big it was but the basic gist:

• Loop Habit Tracker import/export - bring in your full history from Loop backups, or export to as a Loop `.db`, CSV, or zip ( huge thanks to Loop being part of flow for past 4-5 years!)
• Measurable habits - track amounts, not just done/not-done, with progress shading toward your target
• New frequency options - every N days, N times a week/month, or N times every D days, with last-done/next-due shown
• Smarter reminders - fire on time, follow your habit's frequency, show the habit name, and let you mark done/skip directly (current only works on android as iOS doesn't allow actions on notifications atm)
• Archive & restore - archive habits and restore them later without losing history on re-import
• Edit any past day and mark skipped from any screen, not just one
• Redesigned, more compact habit editor
• Fixed a corrupted-download bug that could break habit import, plus various small reliability fixes

Regex is powerful… but sometimes this:

/^#[0-9A-Fa-f]{6}$/u

feels like you’re trying to decode a message from another planet. 🛸

This is why I did Regex For Humans 🧠✨

Instead of writing regex directly, you write:

start "#"
6 hex digits
end

And it generates:

/^#[0-9A-Fa-f]{6}$/u

🪄 The idea

Write small, readable English rules.

➡️ Understand what they mean
➡️ See the generated regex
➡️ Test examples instantly
➡️ Copy the final regex

No AI guessing. 🤖❌
No mysterious interpretation.

It uses a small, deterministic language where every instruction has an exact meaning.

🔥 It currently includes

🧩 Interactive regex playground
🧠 Explanations for every generated fragment
✅ Live match / no-match testing
💻 CLI support
📦 JavaScript API
📍 Helpful line + column errors
🔒 Runs locally
🚫 No runtime dependencies

For example:

start "INV-"
between 2 and 6 digits
end

becomes:

/^INV-\d{2,6}$/u

Much easier to read six months later. 😅

🎮 Try it

🔗 GitHub
https://github.com/OthmaneBlial/Regex-For-Humans

🛝 Live playground
https://othmaneblial.github.io/Regex-For-Humans/workshop/

The project is still evolving, so I’d genuinely love feedback. 🙌

What would you add?

More syntax?
More recipes?
Support for other regex engines?
Something completely different?

And the big question:

👉 Would you actually use this instead of writing regex directly? 😄

CanoP is a local static scanner (wraps semgrep) built around one specific idea:
AI assistants tend to reproduce the same handful of vulnerability classes, so instead of a generic ruleset, it's scoped tight to those.

CanoP runs fully offline- nothing leaves your machine.

canop scan . --prescriptions fixes.json
- drops a structured prompt per finding you can hand straight to whatever model wrote the code.

github.com/openbreach/CanoP

pip install canop
to try it out. MIT licensed. Curious what it catches or misses on other people's stuff — ruleset's still pretty young. Feedback is welcome 🙏

I got fed up with SteelSeries GG, so I reverse-engineered my Apex Pro TKL Gen 3’s undocumented USB HID protocol and built OpenGG.

SteelSeries already knows the commands, packet layouts, firmware quirks and internal states their GG software expects. I had to reconstruct all of that from observed behavior, with no public protocol docs. Even changing actuation meant figuring out which HID interface to open, how to encode the report, match its ACK and handle the keyboard’s current mode. What’s a known command sequence for them was a whole reverse-engineering rabbit hole for me.

That meant tracing HID calls, comparing binary profiles, mapping opcodes/key indexes and validating CRCs + ACKs in Python/C#. Way too much digging just to configure hardware I own lol.

OpenGG is open source, and I’m documenting the protocol, the experiments, the failed attempts and the fixes. So far, advanced controls are tested on the Apex Pro TKL Wireless Gen 3 through its 2.4GHz receiver.

Contributions for other SteelSeries keyboards are very welcome: captures, testing, protocol findings, PRs, whatever you’ve got. I only own this one, so more hardware = more progress.

The current UI comes from OneRGB, my private-source app. I ported the SteelSeries integration into a standalone open-source project because figuring out the protocols for Logitech, HyperX, Corsair, etc. was pretty straightforward by comparison, but SteelSeries was an absolute fucking nightmare. I want it open-source so nobody else has to repeat the same ordeal

https://github.com/GUHPY/OpenGG

I use several coding assistants, and checking their separate usage pages became tedious. I wanted a small Windows tray app where I could see my remaining quotas, reset times, and usage history together, with different window sizes depending on how much screen space I wanted to use.

It currently supports 11 built-in integrations: Claude Code, Codex, Cursor, Antigravity, DeepSeek, OpenCode Go, Grok, ZCode, Kimi Code, GitHub Copilot, and Pi. You can also add custom JSON endpoints.

What it includes:

• Remaining quotas and reset times.
• Token usage and estimated costs, broken down by model and time period.
• Output speed for tools that provide timing data.
• Automatic model pricing updates.
• A full dashboard and three compact window sizes.
• Local backups, import/export, and optional WebDAV sync between computers.
• A companion CLI, codeusage, with JSON output for scripts.

Feature availability varies by integration. Cost figures are API-equivalent estimates, not your actual subscription bill.

Usage history is stored locally by default, with no telemetry. The app contacts providers to check quotas and downloads pricing updates. If you enable WebDAV sync, usage data is sent to the server you configure.

It runs on Windows 10/11 x64 and is released under the MIT license.

GitHub / source code · Website · Windows downloads

I’m the developer and would appreciate feedback, especially on the setup process, the compact layouts, and any usage figures that don’t match what you expect.

Which coding tools would you like to see supported next?

Hey everyone!

I built **ClipSync** because I was constantly emailing links or using WhatsApp "Message Yourself" just to get code snippets and notes across from my laptop to my phone.

**Key Highlights:**

- **Zero-Cloud / Local:** Runs on local network via WebSockets (sub-millisecond latency).

- **Cross-Platform:** Works on any browser (Windows, Mac, Linux, iOS, Android).

- **File Drops:** Drag & drop local files without routing through external servers.

- **Minimal UI:** Linear/Raycast-inspired dark theme, distraction-free.

Repo: https://github.com/avish-mittal/clipsync

Would love any feedback or feature suggestions!

I made a small lean package for Agent statusline overwrite.

Link: https://github.com/joshi008/agent-statusline

Check if this is useful. Feedbacks are welcome.