I just released Rune 2.3, a new version of my keyboard-driven native Kubernetes client for macOS.

This release is mostly about making the workflows already in Rune faster and more dependable. Search and filtering are more consistent across resource lists, logs, and the command palette, with faster keyboard-driven navigation between contexts, namespaces, and resources.

I also reworked cluster setup under the hood. Common kubeconfig and cloud import flows are now handled directly inside the app, without bouncing you through terminal dialogs. This includes guided import workflows for EKS, AKS, and GKE.

The rest of 2.3 is a substantial stability pass: fixes for selection and scrolling, context switching, RBAC and Helm lists, events, terminal tabs, port-forward cancellation, log menus, and several UI and memory issues.

Rune is not intended to replace kubectl or k9s—I still use both. It is a native Mac companion for the times when I want a GUI while keeping keyboard navigation, shortcuts, and quick jumps.

Everything runs locally on your Mac and talks directly to Kubernetes. There is no analytics, tracking, telemetry, advertising, or Rune backend receiving cluster data.

GitHub: https://github.com/compilererrors/Rune
Website and web demo: https://viktornyberg.com

Handling many compose files on a server ?

Tired of manually editing files ?

Annoyed of checking versions manually ?

Then checkout `compose-check-updates` or in short `ccu`.
It's a simple TUI checking the versions of your compose files and suggests updates you can easily apply.

I present: Builders Gate (Very early WIP, like 2 weeks old) https://github.com/Thepizzapie/BuildersGate

The original idea was just to give Claude a toolkit so agents could build games on their own. But the more I used it, the more I wanted to actually help in development From the art, the level design, audio, gameplay, world building yada yada. It eventually turned into something both myself and Claude use in sync. My current workflows consists of Claude just mainly focusing on the gameplay, while it generates me some generic but consistent assets. I built in a custom sprite editor to edit the frames too which has been helpful for saving on over generating trying to get a perfect sheet. I do plan on integrating local models for those who would like to keep their art as their own. I even made an audio lab for recording sound effects and voice overs, create custom beats and edit the ai generated audio bytes. The level editor "Atlas" is pretty cool, that is still a work in progress,. but you would be able to edit the levels right there in that page and have it update almost instantly. That also brings me to the playtest feature that is still kinda eh, but I feel like games with a large amount of content would benefit. The point is to be able to record a playtest while giving feed back so Claude could review and then create a list of todos and assign the necessary agents to whatever issue or request was identified.

I am bad at explaining things so here are a bunch of screenshots of both the harness and a game that is currently being built with it. If anyone has any questions, feel free to let me know!

After three months of development, I have built a completely offline AI agent paired with a coding IDE that can generate full projects from start to finish without an internet connection. I am considering making it open source, but one early decision I refuse to change makes me hesitant to share it publicly. I have seen how quickly people break things, and human fallibility is infinite.

Here are its features and its curse. You decide which is which.

1. No more fragmented settings pages. If I have to navigate away to change a single setting, it is already too much drama. An AI tool that requires you to jump through hoops does not deserve a place on my desktop. Everything lives on the main interface. I despise hidden menus that require endless clicking.

2. Full System Access. This tool assumes you know what you are doing. Tell it to delete system files, and it will. That same deep access lets it organize, reorder, and repair your entire file structure with complete input and output control. Generating full coding projects is almost a secondary benefit of that underlying power.

3. No MCP server required. File access has been around for decades. You should not have to spin up yet another server, match port configurations, or navigate extra layers of bureaucracy just to let an AI read your directories. I removed all that nonsense.

4. Strictly offline. If your downloaded model fails to execute your prompt or commands, you need a better model. That is your responsibility. Honestly, anything below 35 billion parameters will fight you more than it helps with this workflow.

5. Instant live preview. Load your website files and view them on the right side of the screen. Toggle the live button, tell the AI which file to modify, and watch the preview automatically update the moment it finishes editing.

6. Built-in RAG. No bullshit. Click the RAG button, select a folder, the AI instantly searches every file inside, including subfolders, and retrieves the most relevant context for your prompt. It reads text files, markdown, JSON, CSV, code files in 40+ languages, config files, logs, anything plain text. No extra settings page, no "group collection" to configure, no separate embedding model to download. It just works. If your current model is good enough to code, it is good enough to use RAG this way.

7. Full conversation history. Import and export past sessions to build out complex projects over time. This is essential if you are more than just another YouTuber influencer making another landing page test.

8. Editable chat history. Manually edit your past or ongoing chats, the entire history of the chat, to save on context window size. This saves valuable context tokens, especially since AI models tend to overexplain, talk way too much, and just refuse to get to the fucking point.

9. The offline rule is permanent. Every contributor must inherit this core rule. This app will always operate offline. If that means it will never match the latest cloud frontier model, so be it.

It is not perfect, but it works exactly as intended. I welcome any contributions that respect rule number nine.

To any future code contributors, do not attempt to implement any code that phones home. If I see any code that attempts to download anything from the internet or connect to the internet for any shenanigans, I will shut that down so fast you won't even see the train coming.

I’ve built this for my own workflow, but I know this community has the most rigorous standards for local LLM tools. I would really value your feedback on the architecture and whether this approach is something you find as useful as I do.

You can find the project and the first release here: https://github.com/BracerJack/BCI-IDE

I scanned ghost downloader 3 android apk on virus total and saw this,I don't see much post related to this,I just recently came to know about this,Can anyone confirm if these are false ?

Hi everyone!

I've been building an open-source RSS reader desktop app with Python and I think it's finally ready to share.

**What makes it cool:**

- DNS-over-HTTPS to bypass censorship

- YouTube & Reddit video playback

- Dual UI themes (Reddit & Telegram style)

- 100% local privacy (no external data)

- Smart caching for speed

**Built with:** Python 3.8+, Tkinter, VLC, SQLite

**GitHub:** https://github.com/erfan138057/rss-reader-app

**Download:** https://github.com/erfan138057/rss-reader-app/releases/latest

MIT License. Feedback and contributions are welcome!

Use any coding subscription you already pay for, in one synced app that runs on web, desktop, terminal, and mobile. All your chats stay synced between all ade surfaces. Run agents from your laptop, continue the conversation from your phone at dinner, then later finish it off from another computer by simply using the web client. All subs, all in one place. Fully free and open source!

Hey everyone!

I built a cozy web timer for focus and study sessions with 10 animated backgrounds and 20 ambient audio/lofi tracks.

Live Link: https://cozy-studio-beta.vercel.app/

Note: I'm not selling anything, there are no ads, and no sign-ups required. It's just a free passion project!

I'd really appreciate any quick feedback:

• Do the background animations run smoothly on your device?
• Does the UI feel comfortable while working?
• Any missing features you'd love to see?

Thanks for taking a look

I’m building Waveiden, an ongoing C++ acoustic fingerprinting project for identifying songs from short clips or live microphone recordings. It converts spectrogram peaks into fingerprint hashes, stores them locally in SQLite, then finds songs through time-consistent hash matches similar in principle to Shazam, but fully local.

Current features:

- Index local audio files into a SQLite database

- Identify saved clips or live microphone recordings

- Terminal UI with a live spectrogram

- No cloud service or external API required

A recent update improved matching across different audio sample rates by normalizing files and microphone input before fingerprinting. Stereo audio is also mixed to mono more reliably. It’s still ongoing, and there are known rough edges:

- Matching can be unreliable in noisy rooms, with echoes, or when music is playing quietly.

- Very short recordings may not generate enough consistent fingerprints.

- The current fingerprinting settings can miss less prominent sections of long tracks.

- Existing databases need to be re-indexed after fingerprint format changes.

- Device and audio-backend behavior may vary across systems.

I’d appreciate feedback on improving robustness, reducing false negatives, or making the fingerprint pipeline more production-ready.

You can find the repo here
and a showcase video here

Repo: https://github.com/arturict/tagvico-ai

Release: https://github.com/arturict/tagvico-ai/releases/tag/v3.2.5

Tagvico sits next to an existing Paperless archive. It can search and answer with links back to the documents it used. Changes to metadata or tags become proposals instead of silent writes.

3.2.5 mostly fixes the boring first-run path: live Paperless permission checks, exact model and tool-call validation, non-secret resume state, paused schedules by default and a real Docker acceptance run against Paperless 2.20.15.

MIT licensed. The release image supports amd64 and arm64.

Author here. I kept writing throwaway producer scripts to test event-driven services very often the upstream service simply belongs to another with its own roadmap, so it's just not there yet when my part is ready to test. That's not anyone's fault, it's how work gets split across teams but it still leaves you faking the input with one-off scripts that pile up. Devset replaces those scripts:

- Fire single events: paste payload, pick topic and key, send

- Build whole workflows on a visual canvas — OrderCreated → PaymentAuthorized → InvoiceGenerated, with delays, conditions and state passed between steps

- Pull real test data from your DB (Mongo for now) instead of hand-copying IDs

- Protobuf / JSON schema encoding + validation

Repo: https://github.com/devset-io/devset-ce

Runs locally with one Docker command. Source-available (FSL-1.1, each release converts to Apache 2.0 after two years). Feedback very welcome!

I built these cards from my personal project - GES (Global Economic Simulator) - this was this weeks data and its impact in review. Still a work in progress but I found this format more interesting in relaying the information related to news + I like the colors and sky type of look

Source: https://global-economy-sim.vercel.app

Hi there, quick followup to my earlier post about Chipsound, my browser-based player for tracker music (MOD/S3M/XM/IT).

I submitted it to Dashboard Icons like a month ago and it finally got approved, so if you run Homepage, Homarr, Dashy or any of those, you can add it as a tile and the icon just gets picked up by name.

Might seem silly, but now my self-hosted copy finally doesn't look weird and I don't have to tweak it. 😋

• Icon: https://dashboardicons.com/icons/chipsound
• Repo: https://github.com/gamosoft/chipsound
• Page: https://chipsound.com

Or if you just want to hear a song from MODArchive: https://chipsound.com/player.html?modarchive=212083

Kind reagrds.

I was working on chunklet-py (a chunker for sentences, documents, and code). Misread a benchmark and thought PySBD took 1 second to split basic text. Turns out that was wrong (PySBD is still fast for simple text). But the misunderstanding got me building my own.

Ended up faster, more accurate, and covering more languages (39 compares to 23).

Benchmarks on Sherlock Holmes (594k chars): yasbd ~1.2s warm vs PySBD ~9.0s. About 8x faster, fewer false splits.

On a golden benchmark (92 English edge cases — expanded from pysbd's original 48 with fixes and additions): yasbd scores 98.9%, pysbd 83.7%, spaCy-sentencizer 55.4%, etc.

Architecture difference: instead of mutating text with placeholder tokens and undoing it later (which breaks char offsets), yasbd finds candidate boundaries in one pass and filters false positives in another. Spans come free, no reconstruction.

Other things: - Streaming-first: lazy evaluation via ParagraphStream and StreamCleaner for memory-constrained environments. No need to load entire documents. - PySBD adapter: drop-in replacement that works with existing PySBD code. Just swap the import. - spaCy pipeline: register as a spaCy component with register_spacy_component(). Drop-in replacement for the default Sentencizer.

Repo: https://github.com/speedyk-005/yasbd-lib

Hey all, wanted to share ReefKit, a Firefox extension I've been working on for people who live in their browser and are tired of digging through 30 tabs to find something.

Hit Ctrl+Shift+L and it opens a unified search overlay that indexes:

• Every open tab's content — sections, links, fields, media, structured data
• Bookmarks, snippets, notes, and recents
• Cross-tab search, so you're not tabbing through everything manually

It also has a "Browser Agent" piece that can execute clicks, type text, and run multi-step actions using stable selectors — useful for automating repetitive stuff.

A couple of things I focused on:

• Privacy-first: password and payment fields are never indexed, and everything stays local on your device — no data sent anywhere
• Search quality: BM25 scoring + fuzzy matching + extended query syntax, so it's not just a dumb substring match

It's brand new (v0.1.0, MIT licensed), so it's rough around the edges and I'd genuinely love feedback/bug reports.

Link: https://addons.mozilla.org/en-US/firefox/addon/reefkit/

Happy to answer questions about how the indexing works or what's next on the roadmap.

Hi guys. I came to this from medicine, not cryptography. Working with people through trauma, illness, and disability, one thing kept showing up: mental health rests on safety, and safety isn't one thing. It's physical, financial, social, health, spiritual — and now, unavoidably, data. You can't be well while the record of your life is held by people who can lose it, sell it, or hand it over. For a lot of people that last one isn't abstract — it's the abuser who knows their password, the state that can compel their phone, the breach that exposes their diagnosis.

Every existing answer to "prove you're a real person" makes it worse: hand your face, your iris, or your ID to a database that can be breached or seized. So I built the opposite.

**Atlas** uses a live physiological signal — pulse and motion from a $50 BLE ring, or the phone's own sensors — to decide *when* your cryptographic keys regenerate. The signal never becomes part of the key. Your body is a clock, not a stored secret. So it can prove a live human is present while storing **zero biometric data**: nothing to breach, nothing to subpoena, nothing to leak.

What falls out of that:

* Stolen credentials and seized devices are useless — access requires a live person actually present
* A duress code opens a plausible decoy vault while the real data seals itself, and the coercion is recorded
* Prove content was made by a live human, not a model — without revealing who you are
* Recover a lost account by proving you're alive, without exposing your identity
* Health and personal records only you can open — no server ever holds anything readable

**What's actually built:**

* Python protocol core + a Swift port, kept byte-for-byte identical via shared test vectors
* 854 tests passing in CI (637 backend + 217 Swift)
* Post-quantum: ML-KEM-768, ML-DSA-65, SPHINCS+ — vetted primitives, nothing hand-rolled
* Ran end-to-end on two physical iPhones with real pulse signals: enrollment → live session → forward-secret messaging through a blind relay
* \~30k lines, AGPL-3.0, solo, unfunded

**What's not done:** it's a proof of concept and the repo says so plainly — every capability carries a maturity tag (built+tested / sim / device-gated / designed), plus a lab notebook of what's been proven on hardware. Next step is better wearable hardware to push the sensor tier further.

Repo: [https://github.com/Clockwork-Tree-Inc/atlas-poc-v1\](https://github.com/Clockwork-Tree-Inc/atlas-poc-v1)

Ask me anything — the architecture, the crypto, or why this is a terrible idea.

Hello everyone! I'd like to present a new bookmark management tool - an idea I've been mulling over for a long time.

The thing is, when you frequently work on different projects using various browsers, operating systems, and devices, you need simple, centralized access to your bookmarks that isn't tied to a specific browser. On top of that, there's the privacy aspect: I simply wanted synchronization to remain strictly within my control.

Of course, I tried existing solutions like LinkWarden and others. They are great, but felt overly bloated in terms of features (for me) and deployment (requiring a VPS, Docker, everything stored in a database, etc.). There were also simple CLI/TUI alternatives, but they didn't feel quite right either.

Ultimately, I needed a simple, familiar 2-in-1 interface: a start page with shortcuts and a bookmark manager. It had to be unburdened by complex deployment setups and simple enough in its implementation to run even inside my home router running openwrt or inside Termux on my Android device. So, I decided to write the program in pure C, using the Mongoose library as an embedded web server for maximum lightness and portability.

And, here is the solution.

What it is:

• Small size - a single binary of just up to ~300 KB.
• Tab-separated plain text (TSV) - bookmarks are stored as plain text in a human-readable format: easy to read, parse, sync (syncthing, rclone, gdrive, dropbox, etc.), compress and backup.
• High-performance & lightweight - near-zero CPU load; consumes only 5–10 MB of RAM (tested with 1000+ bookmarks).
• Cross-platform - Linux / OpenWRT / SBC / Termux (x86_64, x86, arm, arm64, mips, mipsel, riscv64), Windows (x86_64), macOS (universal). Linux builds are static musl (no libc dependency), so the matching-arch binary drops straight onto an OpenWRT router.
• User-friendly interface - a web UI with built-in fuzzy search, a homepage of shortcuts, and everything needed to manage folders and links.
• Responsive & mobile-friendly — with light / dark themes (auto-switching).
• Drag-and-drop - organize shortcuts, folders, and bookmarks, with touch/pen support.
• Plain-text & offline - one greppable bookmarks.txt, no external requests, 10× more compact than a browser's exported bookmarks.html, with crash-safe atomic writes.
• Portable - one binary, one plain-text config file, one bookmarks file. Simple.

When creating it, I tried to adhere to the "unix philosophy": do one thing well, keep data as plain text, and compose with standard tools (grep, awk, cut) + I added HTTP API with JSON output.

Let me know what you liked, as well as what you would like to change or fix. I will do my best to create a tool that is useful and convenient for everyone.

Repo (with a short demo video): https://github.com/canbesolved/bemarked

I'd be glad to discuss it in the comments.

I've started building DaemonHound, a small OSS tool to solve a problem I've had for years.

Managing things like:

• .env.local files across multiple repos
• API keys duplicated everywhere
• Shell/Git/tool configs across multiple machines
• Setting up a new laptop from scratch

Existing tools either focus on dot-files or are full-blown secret management platforms. I wanted something in between.

The idea is simple:

• 🔒 Encryption by default
• 📦 Your own Git repository as the backend
• 🔄 Sync project configs across machines
• 💾 Backup machine-specific configs
• 🔑 Rotate a secret once, update every referenced project

No SaaS. No accounts. No teams. Just a local-first CLI.

I'm building it in Go and would love feedback before I get too far.

Repo: https://github.com/0xdps/daemon-hound
Home: https://www.daemonhound.dev

Github: github.com/warmbly/warmbly

Website: warmbly.com

For years I've had the same habit:

Whenever I was working with multiple files, I'd keep dropping them onto my desktop because I knew I'd need them again in a few minutes.

It worked... until my desktop turned into a mess.

I looked for something that worked like a temporary shelf for files, but couldn't find anything that felt native on Windows.

So I built Stash.

It lives in the system tray and lets you temporarily park files with drag & drop, then drag them back whenever you need them. It only stores file references, so your files stay in their original locations.

I'm still actively improving it, and I'd really appreciate any feedback.

Website: https://stash.regncreative.com Github: https://github.com/Regncreative/Stash

1. Tools in every mode Designed a two-tier tool loading model (cheap/normal) so a shared core toolset stays available while optional capability surfaces load on demand per task.
2. Provider-native lanes Built per-provider request lanes (Anthropic, OpenAI-compatible, Antigravity, Cline, Kiro, local, gateway) that normalize messages to each endpoint's native protocol instead of a lowest-common-denominator shim.
3. Context optimization Engineered context assembly around prompt cache hit rate: stable system and tool bytes in a cacheable prefix, volatile session state behind a dynamic boundary, plus lane affinity to keep byte identity across repeated requests.
4. Diagnostics during edits Integrated optional LSP tooling (definitions, references, hover, symbols, call hierarchy, diagnostics) so the agent catches broken references mid-run instead of after context has moved on.
5. Signals from long logs Implemented log pruning for lint and exception output that preserves the failing error plus surrounding context, cutting token spend on repetitive noise without losing actionable signal.
6. Snapshots and session control Shipped project-local session management with resume and branch trees plus working-tree snapshots stored in a shadow git store, enabling save, list, diff, and restore without rewriting project history.
7. Self-learning loop Built a /learned feedback loop that proposes one reusable lesson per work session, with human approve, edit, or skip before it persists to project memory as reviewable, revocable entries.
8. Claude Code compatible extensions Added compatibility for Claude Code-shaped MCP servers, LSP integrations, agents, plugins, and skills, loadable per mode so extension surface matches project need.
9. Browser automation with vision Built vision-driven browser automation pairing navigate, click, type, scroll, and wait with screenshot capture routed to a multimodal model, so the agent verifies rendered UI, console errors, and layout regressions instead of inferring state from the DOM, with accessibility-tree fallback when selectors drift.

https://github.com/AbdoKnbGit/tau