I maintain ai-rulez v5, an MIT-licensed CLI. It's a CLI and MCP for managing the instructions, skills, and settings that coding agents use in a repository.

Here’s a small supply-chain example you can reproduce locally. In a scratch Git repo, run ai-rulez init lock-demo --yes --skip-content, then ai-rulez add rule review --content "Run the documented tests." Run ai-rulez generate and ai-rulez lock. ai-rulez lock --check should pass.

Now run ai-rulez add rule docs --content "Check examples against implementation." With v5.13.2, ai-rulez lock --check exited 2 and reported both the newly added rule and the resulting change to AGENTS.md. ai-rulez lock --diff lets you review the change before accepting it with ai-rulez lock. The lockfile guide lists the inputs and outputs the lock covers.

I'm happy to hear any comments. If you find the tool useful, star it. It really does help. And of course, I'd love to see people use it and get involved with the project.

Move It moves browser data between devices: cookies, saved passwords, extensions with their settings, bookmarks and history. It also moves between different browsers on the same machine, Brave to Chrome and back, no pairing needed.

How it works: pair two devices with a short code, your data is sealed into one encrypted file, and the key stays in your OS keychain, you never type it. The file travels through Google Drive, Dropbox or a folder you pick. No server, no account, nothing for me to read.

Before a move you get a preview of what will move. There is a backup before every write, an undo for the last move, and a report listing anything that got skipped.

Limits, up front:

• v20 App-Bound cookies and logins do not move. They are tied to the machine and browser install by design. They get detected, skipped and counted, never modified.

• Builds are unsigned, so Windows and macOS warn on first run.

• Chromium family only (Brave, Chrome, Edge, Chromium). Firefox is not supported yet.

• It is v0.1.0. Rough edges exist.

My test bar was a real Brave profile moved into Chrome, opening sites still signed in, extensions working. That passes, and the engine is tested on Linux, Windows and macOS.

Source and downloads:
https://github.com/0xovo/move-it
https://getmoveit.tech

Bug reports and blunt feedback welcome, both are more useful than praise.

Hello everyone,

I could not find a good looking open source app for split tunneling where I can use WireGuard and Tailscale at the same time, with a different exit for each app. So... well, I built one for me, and as it worked quite well for me and some friends, I released it.

What it does: you make routes, each route has its own exit, and you put apps in them. Every route can use a different provider, and they all run at the same time. So for example your browser goes out through Mullvad in Sweden, a streaming app through NordVPN in the US, some apps through your own WireGuard server at home, and banking goes direct with no VPN. Tailscale (or your own Headscale) runs next to it, so your home network stays reachable. You can sign in to a few providers in an easy way, or just import your own WireGuard or OpenVPN configs.

All the code is on GitHub under the GPL, built on sing-box. No ads, no tracking, no account. There is an Android and a Mac version, and an enthusiastic user of the Android app also made an unofficial Linux port from the code, which is exactly why I wanted it open. I am working on an Android TV version as well.

I know it's not the most technically advanced tool out there, and you can also set up split tunneling on your router. But I travel a lot and I am not into technicalities, so I wanted something nice looking and easy to cinfigure: import your WireGuard configs, pick an exit for each app, done.

Android: https://github.com/quiet-crafts/unbraid

Mac: https://github.com/quiet-crafts/unbraid-mac

Website with guides: https://unbraid.app

Hope you find it usefull. Issues, ideas and comments are welcome!

[HyperStream] — High-performance 128-thread parallel download accelerator and BitTorrent client for Android, powered by a native Rust core.

* GitHub Repo: https://github.com/djsusmith/hyperstream-android

* Live Showcase & APK: https://djsusmith.github.io/hyperstream-android/

* License: GPL-3.0 (100% Free & Open Source, 0 ads, 0 telemetry)

Tech Stack

* Core Engine: Written in Rust using `tokio`, custom work-stealing segment halving down to 12 KB chunks, and `librqbit` for embedded BitTorrent swarm handling.

* Frontend: Kotlin & Jetpack Compose (Modern Obsidian dark theme, reactive telemetry, Material 3).

* Bridge: Zero-copy JNI / C FFI Native Bridge (`libmdm_android.so`).

Key Features

⚡ Up to 128 Parallel Connections:* Real-time socket shedding and dynamic connection pooling that easily saturates high-speed 5G and Wi-Fi 7 connections.

🧲 Native BitTorrent Swarm:* Magnet links, torrent files, sequential downloading (stream while downloading), DHT, and PEX without any third-party daemon.

🎬 Built-in Media Grabber:* Direct 4K YouTube stream extraction and watermark-free video sniffer with multi-stream audio/video muxing.

🔋 Android Background Resiliency:* Foreground service with partial WakeLock and High-Performance Wi-Fi Lock to prevent system Doze throttling.

📂 Safe File Management:* Integrated Android `FileProvider` with 1-tap open and double-confirmation deletion protection.

Context & Why I Built This

Most existing Android download managers are either abandoned or filled with intrusive full-screen ads, tracking SDKs, and paywalled thread limits. I wanted a clean, blazing-fast, genuinely open-source alternative that runs natively on ARM64 without GC pause jitter.

The project is actively maintained (currently on v0.6.0). I’d love to hear your thoughts, feedback, bug reports, or feature requests! PRs and stars are always welcome.

cl0udly started as a way to use OpenCode on my phone without a terminal: the server runs on the phone itself, and you talk to the agent in a normal chat with a small pixel cloud that reacts while it works. This week the first desktop version came out, so the same thing now works on a computer too.

On the desktop you get the chat, a Code view with your projects, and a terminal and a browser next to the conversation. You can give the agent helpers (sub-agents), each with its own model and role, and watch them work on their own clouds. What the agent remembers about you is shown as a graph you can browse and edit.

The phone and the computer share chats and memory. Scan a QR code on the desktop once, and when the phone is on the same Wi-Fi they sync both ways. You can also open a desktop chat from the phone and keep it going from the couch.

The phone app got an update as well (0.0.2 beta-1). Before saving a fact about you, the agent now asks with a small card, and you decide whether to keep it. Replies are formatted closer to Claude's, with headings, lists and highlighted code, and OpenCode updates itself and rolls back if a new version fails to start.

Why not just use the official OpenCode apps? They're good, but they expect a computer: the TUI and the desktop app run on one, and on a phone you can only connect to a server running somewhere else. cl0udly runs the whole OpenCode server on the phone, so it works on a train with no laptop around. On top of that it adds things OpenCode doesn't have: long-term memory about you that the agent asks before writing to, a team of helpers you set up once, and one set of chats and memory shared between your phone and your computer.

It's free and open source. This is an early beta, the Windows and macOS builds haven't been tested on real machines yet, so bug reports are very welcome.

Desktop: https://github.com/mistqkw/cl0udly-desktop/releases

Android: https://github.com/mistqkw/cl0udly-mobile/releases

website:https://texfi-hub.vercel.app/en/download/opencode

HC Player is the only fully native player designed for Windows 11, offering the power of mpv with a simple, seamless, and straightforward interface. This new version simply makes it even better.

New floating playback bar with Mica: Since its initial release, HC Player has offered three control bar modes. Now there are four!

Playlist search: In version 1.4, the playlist panel received a major upgrade, adding support for up to 1,000 items (local and web). The search feature is now just a refinement of what was already there.

18 Crop presets to adjust video framing and more.

Check it out on GitHub for more details:

https://github.com/henzfdev/HC-Player

Slide a touchpad edge for volume, brightness, seeking, Alt+Tab or your own shortcut. Press a corner 1, 2 or 3 times to run anything: lock, screenshot, open an app or website, run a command.Fully customisable: click any zone on a map of your touchpad and pick what it does, record shortcuts, resize zones. The middle stays a normal touchpad.

Rust, no GUI framework (plain Win32 on Windows, evdev + uinput on Linux), ~0.6 MB, no telemetry, MIT.

🔗 https://github.com/arxhr007/margin

lazybw lets you browse, search, copy and edit your Bitwarden items without leaving the terminal, with Vim-style keys. It runs the official Bitwarden CLI in the background and leaves all vault cryptography to it.

https://github.com/SyscallBrain/lazybw

Attention is sacred they say. Culler helps build projects with that in mind.

Culler is a project factory that runs on your own Mac. You own the factory, the code, and the final say of how your project grows. Its agents work toward your vision, on your repositories, through any AI provider.

You define a vision that states your project's open-ended, high-level goal and Culler proactively proposes and submits works toward your stated intents.

Additionally, you can define new work yourself or with the help of Collie, your Culler assistant.

You can review, propose, reject, and otherwise cull work as agents move tasks along the factory line.

Check it out here: https://github.com/vinchenkov/Culler

A Zig program can depend on a file without importing another Zig module. @embedFile("assets/banner.txt") ties the program to that asset, but a code-only dependency picture can leave it out.

ArchUnitZig, my MIT-licensed architecture-testing library, keeps that edge as a resource dependency. It also distinguishes project files, compiler modules and unresolved targets, with source locations attached.

Useful when the interesting dependency isn't code

For example, you can inspect which source file embeds a configuration asset instead of treating the asset as an unrelated extra sitting in the repository. This is static analysis of literal builtins, not a promise to discover arbitrary build-script inputs.

It's free and open source. The v0.0.2 preview targets Zig 0.16.0; the README documents the dependency categories and current limits: https://github.com/dragonsec-ai/ArchUnitZig#zig-dependency-classification

I've been building an Android editor for people who miss Notepad++ on their phone. It is a tribute to Notepad++ and nothing more: it is not affiliated with the Notepad++ project, not a replacement for it, and not trying to compete with it or commercialize it in any way. It will stay free and open source (AGPL-3.0).

To stay faithful to the original, it reuses what Notepad++ is made of instead of imitating it: the same editing engine (Scintilla), the same language definitions and themes, and the same menus and shortcuts.

How it was made: the whole thing was written by Claude Fable 5.2, Anthropic's AI model, and I directed it entirely from the Claude app on my Android phone. I never opened an IDE. The repo includes the automated tests it is checked with on every change. I did manual testing on my phone but more testing from various devices would be helpful.

What's in it so far:

Syntax highlighting and folding for 94 languages, multi-caret and column editing, find/replace with regex, Find in Files, macros, sessions that keep unsaved text

469 of the 481 commands in Notepad++'s menus (the rest only make sense on Windows)

Compare, a Hex Editor and Lua scripting built in, since Windows plugins can't run on Android

Sticky Ctrl/Alt/Shift keys above the keyboard, so the usual shortcuts work on a touch screen

No ads, no tracking, and no permissions at all (not even internet)

It's early: development builds only, no store release yet, and regex still uses a different syntax from Notepad++'s.

Short clips of it in use, the APK and how to verify it: https://github.com/revelationnow/pocketpadpp

All credit for the original goes to Don Ho and the Notepad++ contributors. Feedback is very welcome, especially on how it behaves with your keyboard app.

been building this for a while and it's finally in a state i'm happy with. it's a desktop player for youtube music, tauri + rust, MIT licensed

the main stuff: synced lyrics with karaoke fill pulled from 11 sources (lrclib, musixmatch, netease etc), a 15 band eq, crossfade and gapless, and using your phone as a remote by scanning a qr code. there's also offline downloads, last.fm/listenbrainz scrobbling and 36 plugins you can turn on or off

no account needed, no telemetry, settings and history stay local. it does still talk to youtube obviously, it's not affiliated with google or youtube in any way

https://github.com/tonieninja/zenith-player

feedback and bug reports welcome, there's issue forms now

I built Mewtion, an open-source motion sickness reduction tool inspired by Apple’s Vehicle Motion Cues.

It uses a transparent, click-through particle overlay that responds to vehicle movement using accelerometer data.

Built with Rust, GTK4, and Wayland Layer Shell. Supports KDE Plasma, Sway, and Hyprland, with both native laptop sensors and an Android companion app.

Would love feedback, especially from Linux and Steam Deck users!

GitHub: https://github.com/aayuxh-vim/Mewtion

I have a bad habit. I start a course with a lot of energy, a YouTube playlist, a Udemy course, a PDF book, and after a week I stop. I forget where I was, which video, which page. And nobody notices, so nothing pushes me to go back.

So I built inPace with Claude Code. It's free, open source, and everything stays on your device.

What it does

- Put any course in one place: a folder of videos (even if it's messy, it sorts them), a PDF book (every chapter becomes a module), a YouTube playlist, or a course from the free library

- It remembers the exact second of the video and the page of the book where you stopped

- Pick someone you trust to check your progress: a friend, a sibling, a mentor. When you finish a module you send them a "milestone" with your work, your quiz score and an explanation in your own words. They approve it or not

- Milestones are signed with a key on your device, so you can't edit them later or fake the date

- A free library with 52 courses and 20 learning paths (Python, JavaScript, C#, Git and GitHub Actions, Docker, ML, and more), with written lessons and optional videos from freeCodeCamp and Harvard

- Reminders, notes on any line of a lesson, races with friends, and a little turtle called Tempo who grows a garden while you study

How Claude helped

- Claude Code was my pair programmer for the whole app: the Python server, the pages, the Android app, the release pipeline. I decided what to build and how it should feel, Claude wrote most of the code with me, and I reviewed and tested every change

- Tests were the key. Every feature came with tests, and now there are 237 of them that run on every push on Windows, Mac and Linux. When Claude broke something, a test caught it before a user did

- I asked Claude to test like a real user: open the app at phone size, take screenshots, and look at them. That's how we found the welcome tour was broken on phones

- Claude also wrote the free courses in the library. I made it run every code example, check every YouTube link, and check its own facts. It even caught two wrong facts in its own first draft

- The app itself works with Claude too: "Make a course with AI" gives you a prompt, you paste it into Claude, paste the answer back, and you get a full course with lessons, tasks and quizzes. No API key and no cost

It runs on Windows, Mac, Linux and Android. No account, no server, no ads.

Download: https://mahmoudyosrimahmoud13.github.io/inPace/

Code: https://github.com/mahmoudyosrimahmoud13/inPace

It's my first post here, so any feedback is welcome, good or bad. And if you try it, tell me what was confusing in the first 5 minutes, that's what I'm fixing next 🙏

Loop: Lightweight native video wallpaper & screensaver for macOS [Free & Open Source]

• GitHub: https://github.com/suchithm1999/loop

• Direct Download (DMG): https://github.com/suchithm1999/loop/releases

• Pricing: 100% Free & Open Source ($0)

Problem Most video wallpaper apps on macOS either run heavy WebKit/Chromium browsers in the background (eating 15-30% CPU and draining battery), charge recurring subscriptions, or stutter/pause when looping. I wanted a native tool that uses hardware decoding, runs under 3% CPU on Apple Silicon, and is completely free.

Comparison

• vs. Wallpaper Engine / Live Desktop: Those apps rely on web renderers that consume substantial CPU and RAM. Loop is built strictly in Swift using native AVFoundation (AVPlayerLooper + AVQueuePlayer). Video is decoded once in hardware and shared across all displays in sync, keeping CPU usage under 3% even with 4K video.

• vs. Wallper / Dynamic Wallpaper: Unlike closed-source apps charging subscriptions, Loop is 100% free and open-source. Loop also adds configurable battery thresholds (pause playback only when battery drops below e.g. 20%) and an auto-installed screensaver bundle (LoopSaver.saver) for idle playback.

Key Features

• Hardware-accelerated gapless looping via AVFoundation

• Multi-display support with a single shared decoder

• Automatically pauses when desktop is occluded or displays sleep

• Configurable battery threshold slider

• Auto-syncs matching poster frame for macOS Lock Screen

I got tired of a certain app drifting toward commercialization, so I re-created my own version.

Its main selling (it's free, heh) points are:

- Minimal interface. The toolbar and window borders can both be disabled. Keyboard is enough to control most of the app. F1 opens the list of keyboard shortcuts. Drag-and-drop images or folders straight into the app.

- Small memory footprint.

- Portable. It stores its settings file into the same folder the executable resides, nor does it write any configurations anywhere within Windows/user paths, or registry.

- Support for JPEG, PNG, WebP, TIFF, BMP, GIF, ICO, QOI, DDS, HDR, TGA, and Netpbm images. Animated GIFs play automatically. Not the most extensive support, but enough for a basic user.

- Zoom, pan, and rotate images. Embedded EXIF orientation is applied automatically. Different modes for zooming (Fill, Fit, Fit Height, Fit Width, Lock Size, Auto).

- Run slideshows with fixed or random intervals, shuffle, repeat, and an option to let animated GIFs play through at least once.

- A playlist view with sorting by name, or shuffling. Drag and drop the files to change the order as you like. Playlists can be saved and loaded into files.

- Rename, copy, move, and recycle files or reveal them in Explorer.

- Smooth image browsing, thanks to a caching system.

Windows only, sorry. The app uses Windows APIs, so compiling for other platforms would require some rewriting.

MIT Licensed.

AI Disclosure

The app was developed with the aid of several AI models, including OpenAI's GPT-6 Astra, GPT 6.1 Sol, Mistral's Mistral Large 4, Z.ai's GLM 5.3 and GLM 5.3-Flash, and Deepseek's DeepSeek-V4.1-Flash.

Hope someone enjoys it. Let me know if you do!

RustedGlass (GitHub)

Finding incomplete documentation, broken links and missing test-file matches takes manual inspection. I built RepoRelief to flag these gaps and produce a prioritized maintenance plan with file-level evidence and suggested actions.

Runs locally in your browser or CLI. No uploads, account or API keys. Uses static heuristics, not measured test coverage.

Demo: https://brunnojob.github.io/reporelief/

Source: https://github.com/brunnojob/reporelief

Hi everyone,

If you use a DualSense on PC, you've probably run into games where you need a USB cable to get the full haptic feedback and adaptive trigger effects.

I built DS5 Untethered to use those effects over Bluetooth. The game sees a wired DualSense, and the app sends the game's own effects to the actual controller wirelessly. It works with your PC's built-in Bluetooth or a USB Bluetooth adapter.

For example, I used it with God of War Ragnarök: both haptic feedback and adaptive triggers worked wirelessly.

For games without native DualSense support, you can create your own adaptive trigger profiles and turn game audio into haptic feedback.

It also has per-game profiles, button remapping, gyro and a mouse mode.

It's free and open source, and will stay that way.

Built with C#/.NET 8 and Avalonia. It creates a virtual wired DualSense through a local USB/IP server and usbip-win2, forwards input from the Bluetooth controller, and sends the game's haptics and trigger effects back wirelessly. HidHide prevents games from seeing both controllers.

Source: https://github.com/Midzer00/ds5-untethered

Download: https://github.com/Midzer00/ds5-untethered/releases/latest

If you find it useful and want to support the project, you can star the repo on GitHub.

Happy to answer questions.

Demo video and screenshots: https://www.reddit.com/r/Dualsense/comments/1xvzirq/i_made_a_free_opensource_app_for_wireless/

GitHub: https://github.com/lingdojo/kana-dojo

As someone who loves both coding and language learning (I'm learning Japanese right now), I always wished there was a free, open-source tool for learning Japanese, just like Monkeytype in the typing community.

Here's the main selling point: I added a gazillion different color themes, fonts and other crazy customization options, inspired directly by Monkeytype. Also, I made the app resemble Duolingo, as that's what I'm using to learn Japanese at the moment and it's what a lot of language learners are already familiar with.

Back in January, I even applied to Vercel's open-source software sponsorship program as a joke. I didn't seriously expect to win, and did it more out of curiosity, and yet my project somehow won.

Anyway. Why am I doing all this?

Because I'm a weeb.

Source: https://kanadojo.com

どうもありがとうございます

Hi everyone!

I've just released the first alpha of AppFootprint, a GPLv3 open-source Linux desktop application for understanding where application-related storage is being used.

It provides a graphical inventory of Flatpak, Snap and RPM applications, with storage measurements, dependency exploration and explanations of what the numbers actually mean.

The guiding principle is simple: Understand before you remove.

AppFootprint is strictly read-only. It doesn't delete files or require root privileges.

The first alpha has been tested successfully on Fedora KDE, but I'd really appreciate feedback from people using other distributions and desktop environments.

I'm especially interested in AppImage compatibility, scan reliability, UI responsiveness and incorrect or confusing storage measurements.

Source code and downloads:
https://github.com/ollavarma-create/appfootprint

Bug reports:
https://github.com/ollavarma-create/appfootprint/issues

This is an early alpha, so bugs and incomplete functionality are expected. Constructive criticism and suggestions are very welcome.

Thanks to anyone willing to give it a try!

We released this free text editor named The Scribe. After the Black Forest we went further on our vault to provide a real scriptorium with a very secure database behind. The executable grows like a globefish. The Scribe is a self-contained Digital Artifact: a single static binary with zero GPU, zero DLLs, zero external runtime files, and zero network calls.
With it you can make your own archival PDF, docx, odt, Tex, txt … and we added some goodies from photoshop to help building your documents.
Hope you’ll enjoy it.

https://github.com/ENMEICORP/The-Scribe/releases/tag/v0.1.0

Hi everyone!

I would like to introduce a personal project I have been working on for some time: SecureP2PChat, a private messaging application built with a focus on security, privacy, and cross-platform communication.

The project started from a simple idea: how much can be built independently, without relying on the infrastructure of commercial messaging platforms?

Currently, the project consists of two main components: a Desktop client built in Python and an Android client built in Kotlin. Both applications use a unified protocol and can communicate seamlessly with each other.

Technical Overview

The architecture is built around several core components:

Cryptography and Communication Security

• X25519 for cryptographic key exchange.

• Ed25519 for digital signatures and message verification.

• Argon2id for key derivation from the user's password.

• ChaCha20-Poly1305 for authenticated data encryption.

• HKDF-SHA256 for key derivation.

• FS2 for cryptographic chains and key rotation of individual messages.

• GSK1 for managing sender keys in group conversations.

• TreeKEM / MLS for group key management architecture.

Communications and Infrastructure

The application uses a hybrid communication architecture designed to allow both direct P2P connections and communication via a signaling and relay server when a direct connection is not possible.

The signaling server handles the exchange of information required to connect clients, while traffic routed through the relay infrastructure is protected by cryptographic mechanisms. TLS can be used for transport to the server, and Tor integration provides an additional routing layer for communications.

A key objective is ensuring that the server has zero access to the content of end-to-end encrypted messages.

Storage and Multimedia

The application includes a cryptographically protected local SQLite database, a file vault, and support for voice messages, images, and file transfers.

I also focused on preserving conversation states and the cryptographic material required for operation after restarting the application.

Why I Chose to Build This Project

I didn't just want to build another chat app. I wanted to understand and implement a complete system where cryptography, data transport, relay infrastructure, and client applications work together.

The most interesting challenge was interoperability between Windows and Android, as I had to maintain full compatibility of the protocol and cryptographic mechanisms across two different technology stacks.

I have tested communication between Desktop and Android, including routing via the relay over Tor. I am currently continuing to test and verify P2P connections and file transfers.

The project is still under active development, and I am not presenting it as a certified or independently audited solution. I believe security must be proven through testing, verification, and auditing, not simply by listing the algorithms used.

Repository and Source Code

• GitHub – SecureP2PChat Desktop: https://github.com/andromeda-rt/SecureP2PChat-Desktop

• GitHub – My Profile: https://github.com/andromeda-rt

I would love to hear your thoughts, especially from those with experience in Python, Kotlin, applied cryptography, communication protocols, and information security.

I am looking for technical feedback, suggestions for improvement, and any potential architectural flaws you might spot.

Thank you!

People at work are building small internal apps now, often with AI, and they end up running on laptops or personal cloud accounts. I built Pando to give them a proper home.

You can point it at a git repo, container image, or have your agent upload source code directly. Pando builds it, scans for vulnerabilities, runs it on an isolated network, and puts it behind SSO (e.g. Okta). It also works great on a home server!

It’s AGPL-3.0, written in Go and TypeScript, and is currently alpha, so expect breaking changes.

As a solo dev, I used Claude Code as part of the development process, but the whole project is built with strong spec-driven-development and guardrails. SonarQube, OpenSSF, and extensive testing help keep everything in line.

https://github.com/trypando/pando

What would you consider before using something like this?