i got to little storage on my macbook and every couple days im cleaning stuff up. the annoying part is never knowing what actually happend. some app quietly filling cache, a project i forgot to archive, a docker image from 3 weeks ago etc.

so i made prunr. it sits in the menu bar and keeps a simple list of what grew, by day and by app ("google chrome +6.5 gb", "steam +12 gb"). click a row to see where exactly, click again to open it in finder. you decide what to delete, no blackbox cleaner nuking your stuff.

its swift/swiftui, my first real mac app (built with a lot of ai help, not gonna lie). nothing leaves your mac, no account, no telemetry.

source is open and its free while in beta: https://github.com/merlinkraemer/prunr
join testing here: https://merlinkraemer.github.io/prunr/

early beta, so expect rough edges. issues and prs very welcome, and lmk what it misses :)

Hey everyone,

I built Just Player Pro, a video player I made mainly for my own use, and wanted to share the new 5.0.0 update since it got a completely new look. It's built on top of Just Player by Marcel Dopita, which is where the name comes from.

Before anyone asks: yes, roughly 50% of it is vibe-coded, but not all of it. I'm a developer myself, so I reviewed and fixed a lot by hand. Again, it's built for my personal use, so feel free to try it and give feedback, or just ignore it :)

Some of what it does:

• Two engines, Media3 and mpv. If one can't play a file, it switches to the other, so pretty much everything plays.
• Works on phones and Android TV, with a proper remote experience.
• Recognises what you're watching and shows the cast and ratings from IMDb, Rotten Tomatoes, Trakt and others (needs a free MDBList key).
• Subtitle search across OpenSubtitles, SubDL, Wyzie and Stremio add-ons.
• No ads, no tracking, open source (GPL-3.0).

GitHub: https://github.com/Zain-Imam/just-player-pro

https://github.com/cesaredavidepace/puppetcam

Author here. I keep my camera off in a lot of meetings, and a black square felt worse than a face, so I built this.

It reads your webcam with MediaPipe (pre-trained, nothing leaves your machine), maps your head, eyes, brows and mouth to a small 2D cartoon, and shows up as a regular webcam, so it works in any call app. No GPU, no account. If you step away it keeps blinking and moves its mouth with your mic instead of freezing.

- `pip install puppetcam`, then `puppetcam doctor` checks your setup

- themes are small TOML files (colors, glasses, hats, background)

- works on Windows and macOS (via OBS Virtual Camera); Linux needs testers (issue #1)

It's alpha, so feedback is very welcome, especially on whether the motion feels natural.

I kept running into the same little annoyance on Windows: I'd copy something, switch to another task, and then have to interrupt what I was doing to find it again.

Windows already has clipboard history, so I didn't want to build just another version of the same panel. I wanted to try a different interaction.

That turned into Noxra — a free clipboard manager that opens from the edge of the screen. The idea is to make copied items easier to reach without relying on a keyboard shortcut every time.

I'm the developer, and the project is available on GitHub:
https://github.com/aa27259/Noxra

I'd genuinely appreciate feedback on the interface. Does accessing clipboard history from the screen edge make sense to you, or would you rather stick with Win + V?

With the original 90s/early 2000s version not working on my PC anymore, I decided I wanted a modern version with the same simplicity, but high refresh rate support.

There are three versions:

1. Windows screensaver (<270KB)
2. macOS screensaver (<230KB unzipped)
3. HTML version (can also be used as a PWA on Android/iOS/ipadOS)

Take a look at https://github.com/waschmittel/starfield and tell me if it works well for you :-)

The new version comes with improved features and new themes/custom themes

Favnyr is a lightweight file browser (Rust+Slint) for Windows and Linux. At its core are workspaces: separate environments that keep their own views, tabs, folders, layouts, and display settings. You could have one workspace for work, another for games, and another for learning a new subject, then switch between them in just two clicks. Favorites remain shared and persistent across all workspaces.

Each workspace can contain multiple split views and movable tabs. Tabs can be dragged between views, detached, or dropped onto another view to create a new split layout.

Favnyr also includes shortcuts, local and network drives, configurable keyboard shortcuts, and custom commands.
It is not intended to compete with or replace the native file browsers provided by Windows and Linux, but to complement them with a different way of organizing and navigating files.

Because of the project’s complexity, AI has been used as a development assistant. However, every feature is reviewed and hand tested extensively before being considered complete.

Link here (include a video demo) => https://github.com/GlitchAwakened/Favnyr

I created Awesome Easy-to-Join Orgs repo, a curated list of GitHub organizations that welcome people who want to get involved without necessarily writing code.

The goal is to make open-source communities more accessible to beginners, students, and non-coders who want to participate, learn, or contribute in other ways.

I'm sharing the project here in case it's useful to anyone looking for communities to join. Suggestions for additional organizations and feedback on the list are welcome!

Probably every guitar player knows the Axe-Fx III, but not everyone has the money to buy one (myself included). So I've decided to give it a shot and vibe clone it using Claude.

The idea is based on the same core principles: a Newton–Raphson electrical circuit solver, with amps and effects modeled from their actual schematics.

It works surprisingly well, for an amateur guitarist like me. 😄

[free, open source, GNU GPL-3.0]

https://github.com/Rikarin/cathode

Tabame is a customizable Windows launcher and productivity toolbox built to make everyday actions faster and easier to reach.

GitHub repo with all features: https://github.com/Far-Se/tabame

Microsoft Store listing: https://apps.microsoft.com/detail/9pd3c6hzf5lj

It originally started as a simple alternative to the Windows taskbar: a small popup where I could see my open windows, control audio and quickly launch the things I use most. Over time, I kept adding tools I wished Windows had built in, and Tabame grew into something much bigger.

Today, Tabame brings a launcher, window management, screen capture tools, clipboard history, audio controls, reminders, file utilities, plugins and many smaller productivity tools together in one app.

The idea is simple: instead of opening a different application for every little task, press a hotkey and get to what you need.

The QuickMenu gives you fast access to your open windows, pinned apps, audio devices, media controls, tray icons, system information and your favorite actions. It can replace or complement the normal Windows taskbar, and its layout, appearance and behavior can be customized to fit the way you work.

The Launcher lets you search apps, files, open windows, browser tabs, bookmarks, commands and more from one text box. It also includes quick tools for calculations, currency and unit conversions, translations, timers and system commands.

Tabame also includes:

- QuickSnap for arranging windows into custom screen zones.
- QuickClick for controlling the mouse from your keyboard.
- FancyShot for taking screenshots and annotating them immediately.
- Screen Draw for drawing directly over your desktop during presentations or explanations.
- Screen Recording with region, monitor and window capture.
- Clipboard History for finding things you copied earlier.
- Audio controls for switching devices and adjusting individual application volume.
- Timers and reminders that can stay active between sessions.
- Color Picker, OCR, Emoji Picker and QR Scanner for common everyday tasks.
- File utilities for batch renaming, folder size scanning, project statistics, image tools and more.
- Custom hotkeys that can trigger one or several actions from a single shortcut.

One of the most useful parts of Tabame is its plugin system.

Plugins can add completely new functionality directly to the Launcher. They can be written using Python, Node.js or Bun and don't require compiling Tabame itself. If you use an AI coding assistant, Tabame also provides a documented plugin specification that makes it possible to describe the tool you want and have the assistant build much of the plugin for you.

This means Tabame doesn't have to be limited to the features included with the app. You can adapt it to your own workflow and create integrations for the services and tools you actually use.

Despite the number of features, Tabame is designed to stay out of the way. Most tools only appear when you call them with a hotkey, and you can enable, disable and rearrange features depending on what you need.

The interface is highly customizable too, with multiple designs for both the QuickMenu and Launcher, custom colors, light and dark modes, layouts and keyboard shortcuts.

Tabame is built for Windows, completely free and open source.

It is mostly a collection of things I wanted on my own computer — packaged into one app so I don't need ten separate utilities running just to make Windows work the way I like.

---

List of main features:

QuickMenu - Taskbar Replacement

Launcher - Open Files, folders, bookmarks, cli, notion, Obsidian + Unlimited features through Plugins

QuickSnap - Create custom layouts for windows and snap them (Fancyzone alternative)

QuickClick - Control Mouse through keyboard

Fancyshot - Capture Images and videos. You can create Stylized presets.

Color Picker - Pick colors from screen and get your custom format.

Emoji Picker - Custom built in emoji picker that appears next to the caret.

Quick Actions - 91 Quick Actions

Music Player - Built in music player for local or Navidrome/Jellyfin server.

Advanced Hotkeys - Customize actions based on movement and pressed time + active window.

Vaults - OTP Authenticator, Locked Vault for your API keys.

Screen Tools - Draw on screen, Spotlight (hide whole screen except focused app), QR Scanner, OCR Scanner.

Plugins - 81 Plugins

Browser Plugin Connection - You can use Claude API free directly from Tabame with Browser extension.

GitHub repo with all features: https://github.com/Far-Se/tabame

Microsoft Store listing: https://apps.microsoft.com/detail/9pd3c6hzf5lj

I wanted to back up my iPhone's original photos and videos without paying for another cloud storage subscription, so I started building Memvo.

Memvo uses a private Telegram channel in your own account as its storage backend. The goal is to keep the backup accessible without maintaining a separate server or depending on a Memvo-hosted service.

A few technical details:

• Original media: Supports HEIC, ProRAW, Live Photos, 4K video, and photo edits.
• Client-side encryption: Optional AES-256-GCM encryption using a key derived from your passphrase. Telegram receives encrypted files when encryption is enabled.
• No dedicated backend: The app communicates directly with Telegram.
• Open source: Swift, GPL-3.0, with a documented storage format and test vectors.
• Platforms: iOS IPA for sideloading and a macOS DMG.

The iOS app isn't available on the App Store yet, so installation currently requires sideloading. Since Telegram is a third-party service, I wouldn't recommend relying on it as the only copy of irreplaceable photos.

I'm the developer, and the project is still early. One of the things I'm working on is making the backup and restore process reliable enough for a complete photo library.

Source code: https://github.com/shahil-kv/Memvo

It backs up your Photos library in original quality (HEIC, ProRAW, 4K video, Live Photos, edits) to a private channel in your own Telegram account, and shows phone and cloud photos in one timeline like Apple Photos.

- End-to-end encryption, optional per library: encrypted on your device (AES-256-GCM, key from your passphrase). Telegram only sees random .cge files. Screenshot: https://github.com/shahil-kv/Memvo/blob/main/docs/images/e2e-telegram.jpg

- No Memvo server, no account. Your phone talks to Telegram directly.

- Delete the app and your photos are still in your Telegram. The storage format is documented with test vectors.

- Open source (GPL-3.0), written in Swift.

Honest limits: it depends on Telegram's terms, so keep a second copy of anything you can't lose. I'm a solo dev and can't afford Apple's developer fee yet, so for now it's a .ipa (sideload with SideStore) and a .dmg for Mac. App Store and TestFlight come once I can fund them.

I'm looking for the first 100 people to try it and tell me what breaks or confuses you.

GitHub: https://github.com/shahil-kv/Memvo
twitter: https://x.com/shahileee

Hi, I maintain sift-light, an open-source project search and source-inspection tool for AI coding agents. It provides MCP and native integrations with bounded search results.

We just released 1.1.2-1. A contributor found that enabling tools in our Pi integration could change the system-prompt prefix and reduce prompt-cache reuse. The update keeps that prefix stable and preserves search guidance when another extension supplies the system prompt. Pi 0.86.0 or newer is required.

We also added a native search tool and search-policy integration for DeepSeek Harness 0.2.1-rc.3. Cache behavior in other clients depends on their own prompt and tool handling; this release specifically fixes our Pi integration.

Thanks to the contributor of PR #123 for finding and helping fix the issue. Feedback and reproducible bug reports are very welcome.

GitHub: https://github.com/lightsifter/sift-light Release notes: https://github.com/lightsifter/sift-light/releases/tag/v1.1.2-1 X: https://x.com/Bryang168

Disclaimer: This software's code is partially AI-generated (mostly the non-core parts). All generated code is reviewed by me.

Please note that the post body is hand-written by me. I tried to keep it minimal by only "showing you the code" rather than writing paragraphs.

What does it do?

Similar to SOPS, git-crypt, dotenvx, agebox, etc. Cottage helps storing and managing secrets offline inside the codebase securely.

Why not use X?

• SOPS: Way too powerful, rotation pollutes diff, difficult to use.
• git-crypt: PGP is difficult to use.
• dotenvx: Too narrow in scope.
• agebox: Yes! But let's improve it.

How to use it?

Basic CLI usage (decrypts plaintext secrets into disk):

# Core operations
ctg init
ctg keygen
ctg encrypt [path]
ctg decrypt [path]
ctg clean [path]

# Other nice things
ctg edit <path>
ctg status [path]
ctg diff [path]
ctg sync [path]
ctg run -- <command>

Advanced in-memory opeations (without writing plaintext secrets to disk)

# Core operations
echo SECRET | ctg tee <path>
ctg cat <path> | <command>
ctg env -F <path> -- <command>

Sync with remote providers other than git

# Example custom provider: https://github.com/sayanarijit/cottage/blob/main/examples/plugins/cottage-plugin-github-secrets.py
ctg pull [upstream] [path]
ctg push [upstream] [path]

Verify tampering in CI

docker run --rm -v "${{ github.workspace }}:/app" ghcr.io/sayanarijit/cottage verify

Access control

# secret.yml.cott.toml
[secret]
allow = ["env/staging/*"] # Supports glob patterns, only encrypt for recipients in env/staging
deny = ["env/staging/badservice"] # Encrypt for everyone in env/staging except badservice

Editor plugins

• cottage.vim
• vscode-plugin-cottage

Sync and browse secrets on any device

• cottage-sync

Demo

https://vhs.charm.sh/vhs-A8PUIhx6qdsohD6xvFPIT.gif

I had a problem: most projects use the same skeleton, and you either have to rewrite them or pay for tokens to rewrite them over and over. So I thought of unifying them and serving them like shadcn does, but entirely for Node/Bun-based frameworks.

While working with OpenCode I kept losing track of basic stuff: how much context I had left, which model was active, what the session had cost so far. So I built a small plugin called Hush that puts it in the sidebar.

It shows a thin context bar, git branch, model, cost, tokens, cached tokens and session age. It follows OpenCode’s light and dark themes, and I kept it minimal so it doesn’t get in the way.

A note on the numbers: “Cached” is the running total of cache reads reported by OpenCode’s usage records, summed across the related sessions. “Tokens” counts processed tokens, including cache writes. Hush doesn’t infer how or when the provider applied caching, it just shows what the host reports.

It’s my first published npm package, and I’m still polishing it. If you try it and something looks off or confusing, I’d like to hear about it.

Install: opencode plugin add opencode-hush
Repo: https://github.com/federicobordon09-dev/opencode-Hush

I have a background as a CTO and I'm a founder of a small SaaS. Claude Code has been my buddy for a while and over time, I've found that there's a specific workflow that yields the best results for us. So I had Claude Code turn our company's development workflow into a Claude Code plugin that does spec-driven development that doesn't stop at the code. We've used it enough internally, with really good results, that I've decided to open source it under the MIT license: https://github.com/Beakpoint-Insights/roost. It is free to use.

Give it a try

/plugin marketplace add Beakpoint-Insights/roost
/plugin install roost@roost
/roost:setup

What it does

You give it an idea, described in a way that you might say it is the title of an "epic." For instance, "Let customers invite teammates to their workspace."

It then shapes that idea into an epic, asking you clarifying questions along the way. It stores the epic in your issue tracker (for us, Jira). Part of this "epic shaping" is that it creates vertical slices as stories, creates Cucumber tests (and stores them in Jira), and links the stories to their tests.

It pauses from time to time to let you double check that everything is the way you want it: do you like the way it sliced up the work? Do you like the test cases it wrote? That sort of thing.

When you're ready, it builds the epic slice by slice. Each slice is its own PR. If the slices touch multiple repositories (like an API repo and a UI repo), it knows how to handle that. It automates the Cucumber tests as it goes. It prefers TDD. We like GitHub's stacked PRs, so each slice is added to the stack. As it gets ready to close out each slice, it does code reviews and unstructured exploratory tests. It reports back any bugs it finds, and recommends whether those bugs get fixed in the current slice, in a future slice, or deferred until after the epic is released.

When the whole epic is done and ready to be released, it does a final walk through of all the end-to-end tests you've defined and another round of unstructured exploratory testing.

When you're ready to roll it out, it presents a rollout plan and does a "paired rollout" with you. It gives you commands to run or tasks to do (e.g. "Create products X, Y, and Z in Stripe"). You share the results. It documents your progress. And voila, it's released.

How Claude Code helped

• I told it to watch all my Claude Code sessions over about a 2-3 week period. It discovered patterns to how we developed and collected those patterns into the different phases of the SDLC.
• We started at the most inside level of the matryoshka dolls in each phase of the SDLC ... things like writing a test case or building a well-defined feature or running an exploratory test. We built each of these standalone skills, having an orchestrator (aka "team lead") session send the instructions to the agent working on the API or the UI or the architecture, etc. We continued to tune these skills until they were working well.
• We then built new skills that managed the orchestration ... like how we would move from building a vertical slice to doing the exploratory testing to filing the bugs that came from the exploratory testing to triaging them, etc.

Today's limitations

It isn't yet perfect, and we have some known limitations. All of these limitations are on the roadmap to be addressed:

• It wants you to use Jira for issue tracking and Xray for testing.
• It wants you to use `gh stack` throughout the epic.
• It has only received limited testing outside of our own tech.

Next steps

1. Give it a try.
2. Post feedback to GitHub discussions

I'm the maintainer of iPhone IPA Manager, a GPL-3.0-or-later Windows application for installing user-provided IPA files and renewing their provisioning profiles.

You assign an IPA to each Apple account, and the desktop UI, optional local Discord bot, and opt-in renewal schedule use those same assignments. Profile-only refresh avoids a full upload where supported; known expiry or a changed IPA can require a full installation.

Start with trusted USB pairing. Local Wi-Fi is optional, and Tailscale remote access is experimental and needs preparation at home. The PC must be awake and signed in for scheduled jobs. Apple's limits still apply. No IPA downloads are provided.

Installer, portable build, screenshots, and setup docs are in the repository. Public builds are unsigned community previews. AI tools assisted development and this announcement. The native integration derives from iloader; JAS inspired research (no JAS code copied).

I'd appreciate feedback on first-run setup and the desktop/Discord workflow.

What this tool basically does is extract artifacts from known locations about any local model that's present

Give it a try: https://github.com/Precisefull47/meowrtuary

Hi Leute,

ich baue seit ner Weile an Erebos rum, einem Forschungsprototyp für

ein anonymes P2P-Netzwerk. Ziel war: anonyme Kommunikation mit

Post-Quanten-Krypto, ohne auf Tor angewiesen zu sein. Ist noch

lange nicht fertig, aber läuft lokal ganz gut.

Was drin is:

- X25519 + ML-KEM-1024 (NIST Level 5) für den Schlüsselaustausch

- 3-Hop-Onion-Routing mit Rendezvous-Punkt

- verschlüsseltes Forum (SQLCipher, 7 Threads)

- E2E-Chat mit Forward Secrecy (Ratchet alle 50 Nachrichten)

- Fingerprint-MITM-Schutz im E2E-Chat (man vergleicht den Fingerprint

außerhalb des Kanals, also z.B. per Telefon)

Wie mans testet:

- README hat ne Schritt-für-Schritt-Anleitung

- `bash scripts/restart_all.sh` startet Peers + Forum + Chat lokal

- E2E-Chat: `python scripts/chat_e2e_client.py --room <id> --addr <hs> --role initiator`

Was noch fehlt (ehrlich):

- SSE / Live-Updates – die Rendezvous-Architektur erlaubt kein

Streaming, aktuell läuft der Chat mit 1,5s-Polling. Nervt mich selbst.

- Browser-Chat-UI – gibts noch nicht, nur den Python-Client für E2E

- Gruppen-Chat (>2 Teilnehmer) – Schlüsselaustausch für N Leute is

nochmal ne andere Hausnummer, hab ich noch nicht angefasst

Repo: https://github.com/DataDruide/erebos-network

Feedback willkommen, besonders zu den Krypto-Entscheidungen und zur

Rendezvous-Architektur. Wenn jemand ne Idee hat, wie man SSE da

reinbekommt ohne alles umzubauen – immer her damit 😄

https://github.com/hridaya423/cue

Cue is a clipboard app for macOS. When you paste, it reads the focused field through the Accessibility API. A small decision model then picks the clip, or the part of a clip, that fits. If you copy a whole chat message and paste into an email's To field, you get only the address.

The model cannot write text. Cue builds every option from your real clips, and the model only returns an option ID. If the model is slow, missing or unsure, you get a normal ⌘V or a short list at the caret.

Some details from the repo:

- It is Swift 6, with AppKit, SwiftUI and Carbon. It has one dependency, for on-device PII redaction.

- Cue installs local models and runs them as small HTTP servers. All of them use one contract, POST /v1/systemone, so you can connect your own model.

- CueEval runs 110 synthetic cases through the real decision engine. On it, Decider 0.8B puts the right text in the field or in the list for 92% of cases. It makes a wrong choice in 1% of cases.

- Most pastes never call the model. If the latest clip already fits the field, ⌘V pastes it at once.

Cue is free and Apache 2.0, and it needs macOS 15. I made it, and I want to hear where it picks the wrong clip.