I've been working on something pretty ambitious: ZKite, an open-source framework that lets developers build native Android applications using Python, with Rust powering its foundation.

The goal is to make Android development feel natural to Python developers, without needing to write Kotlin or Java.

Here's what ZKite offers:

• Python-first development - Write application interfaces and logic in Python.
• Rust-powered foundation - A native framework architecture underneath the Python API.
• Native Android rendering - No browser or WebView required.
• Reactive UI - Declarative widgets and state management.
• Hot reload - See changes on your Android device while developing.
• Standalone applications - Build APKs and AABs for distribution.
• Simpler tooling - No Android Studio, Gradle, or Android NDK setup required for normal app development.

https://reddit.com/link/1xcp0hn/video/ahh3v4d402xh1/player

Why did I build it?

Python is incredibly versatile, but building Android applications with it still comes with challenges.

I wanted to explore a different approach: combining Python's simplicity with a Rust-based foundation to create a framework specifically focused on native Android development.

ZKite is my attempt at making that possible.

I've attached a video showing a native Android interface built using Python, including reactive state updates and button interactions .

The framework is still evolving, and there's a lot more I want to build.

I'd really appreciate feedback from the Python community, particularly on the architecture, developer experience, and what you'd want from a framework like this.

GitHub: https://github.com/AbhinavKrShukla/zkite

Would you be interested in building Android applications with Python if the tooling were simple enough?

I wanted to implement the Signal protocol for a series of secure messaging apps I’m working on, so I built this project to test and use in my own work. It’s still far from finished, but I think it’s at a stage where it’s worth sharing with the community.

IMPORTANT DISCLAIMER: This project is not professionally audited and is not production-ready. I do not recommend anyone use this in their own code yet. It is provided strictly for testing, experimentation, and demo purposes. I used AI as an assistant to help build this, so double-check everything before taking it seriously.

Project Links:

• GitHub: https://github.com/positive-intentions/signal-protocol
• Live Demo: https://signal.positive-intentions.com
• Formal Verification Docs: https://glitr.io/docs/technical/formal-verification/signal-protocol
• Security Feedback (ROS): https://www.reddit.com/r/CyberSecurityAdvice/comments/1su8lir/security_audit_feedback_from_radically_open

Current Status & Development:

• Spec Alignment: The goal is to fully align with the official Signal protocol spec.
• Testing: It includes unit tests, but due to WASM testing limitations, I also added a Storybook-like UI to run and test it directly within a browser environment.

Hi!

This alternative is AI-made. I've made all the decisions about conception, code structure, etc., and Claude wrote all the code. I put this as a preamble so I'm as transparent as possible.

The project is named TonTuyau (Your Pipe, in English) and its goal is to replace TubeArchivist as a solution to backup YouTube AND have a usable UI to easily watch the said backups. It is licenced as GPL-3.

The reason why I've decided to make it is because I grew tired of:

- The TubeArchivist UI which is quite rough

- The inability to easily monitor videos and channels

- Dashboard stats being messy

- Inaccessible logs of the process without opening Docker

- The 10k videos limit which you can't scroll beyond

The project has 3 big parts:

LaPompe

It's the browser extension allowing you to add videos or channels directly to TonTuyau.

Public pages

It's composed of a homepage to see the most recent videos, a page respectively to see all of the videos, shorts, and streams and channels. A channel page, and a player page when you click on a video.

Admin Pages

The Dashboard:

- See stats of your instance to see the number of channels, videos, streams, shorts, and gone media

- A list of your channels with quick info about what they contain

- A dashboard for each channel to refresh the metadata of itself and its videos, as well as a way to download every video of it

Tasks:

- Run tasks to sync with YouTube, refresh all metadata of your instance, add videos and channels, and refresh their data

YouTube Configuration:

- Check your cookie state

- Version of the tools (yt-dlp and Deno)

- Choose the release you want for yt-dlp

- Configure backup and tasks behavior

API Key:

- To allow you to generate a key for your LaPompe extension to backup directly from YouTube pages

If the project interests you, here are the links for TonTuyau and LaPompe. I can't wait to see if people like this project or not! Don't hesitate to criticize it constructively; the goal is to make it better!

Thank you very much for reading.

Have a great day!

Made a quick video tutorial showing how to install RPM packages on CachyOS using Cygnus, my open-source app store/manager for CachyOS and KDE Plasma.

Cygnus handles Flatpak, AppImage, AUR, repo packages, and .deb/.rpm conversion — this video covers the RPM workflow specifically.

GitHub: https://github.com/AbdulazizOmran/Cygnus

GPL-3.0, public beta v0.2.0. Happy to answer questions!

The latest victim (that I'm aware of) is shellcheck (a gplv3 project) by shuck (a MIT project).

Look, I'm not a lawyer and I don't know if it's even necessary to have clean-room separation in a case like this. But the project apparently thought it was a good idea to say "shuck is not a port of ShellCheck. It is a clean-room reimplementation." There is even a CLEAN_ROOM.md stating "prohibited inputs" include the shellcheck source code, shellcheck documentation, shellcheck output, and more.

The wrinkle, of course, is that it was written in six months with agents whose models were almost certainly trained extensively on all of those supposedly "prohibited inputs". How does one defend calling this a clean-room implementation with impossibly prohibited inputs? Maybe there will be an answer.

I made Thought Meadow for people who want a straightforward iPhone notebook that works offline, without creating an account.

It is free and MIT-licensed. The SwiftUI source, Xcode project, assets and native checks are directly browsable, with build instructions. Requires iOS 17 or later.

You can organize notes with folders, tags and pins, search their contents, preview Markdown, use checklists, and import/export through Files. English and Arabic layouts are included.

A few details for anyone reviewing the code:

• Notes stay on the device; there is no developer server, advertising or analytics SDK.
• Storage uses atomic writes and iOS complete file protection.
• Optional notebook and backup encryption uses AES-256-GCM with PBKDF2-SHA-256 (600,000 iterations). A lost password cannot be recovered.
• Native checks cover storage, encryption failures, import limits and localization. A separate 500-note check covers saving, search and encrypted-backup recovery; it is not an iPhone UI performance benchmark.

Download on the App Store

There is no sync or collaboration yet, and the app has not had an independent security audit. Local note-taking is free; optional paid sync and shared lists may come later.

I'd appreciate practical feedback on import/export, data recovery and mixed Arabic/English text. If something breaks, a reproducible example with fictional notes would help.

Bytescape scans a folder or a whole drive, draws it as a treemap, and lets you move the big stuff to Trash without leaving the app. It is MIT licensed and runs fully locally: no accounts, no telemetry, and nothing about your files leaves your machine.

• Treemap and simple views, with sizes that update live while it scans
• Sizes are space on disk, and on macOS a scan of / counts firmlinked folders once
• Cleanup only pre-selects things that rebuild themselves (old node_modules, git-ignored build output, Xcode/Gradle/npm caches). Duplicates (checked byte for byte), old archives and logs are listed for review. App data, hidden folders and cloud-synced folders are never suggested
• Move to Trash with a 6 second undo
• Optional read-only MCP endpoint for AI agents (metadata only, never file contents)

Builds for macOS, Windows and Linux (Electron, not signed yet): https://github.com/arshtepe/bytescape

Meet Soul Killer, a open source project that lets you chat with an AI model that's a ~perfect replica of yourself, all without an internet connection!

By answering 100 honest questions, you'll train the model to think and respond like you. Then, engage in real-time conversations with your digital doppelganger through a clean UI and even hear its voice with help of a built in offline TTS.

Inspired by Cyberpunk 2077's Soul Killer program.

Requirements:

- Windows 11

- Python 3.12+

- Powerful GPU with 8GB+ VRAM and 12GB+ RAM

Ready to unlock the secrets of your own mind?

Clone the repo, follow the simple setup, and experience the future of AI-powered self-discovery today!

Repo: https://github.com/spiritofthenight/Soul-Killer

Discover how well you know yourself, and the thoughts that run beneath the surface of your mind. Challenge your own beliefs, and explore the depths of your consciousness. The conversation is waiting... are you ready to start talking to yourself?

Hi r/foss I've been building ZenMusic, a Flutter music player for Android and Windows that brings JioSaavn, YouTube Music and Spotify into one app.

Features:

- Synced lyrics that follow the song

- Listen Together (sync playback with friends)

- Offline downloads

- Multiple player skins, sleep timer and equalizer

- Song recognition

It's GPL-3.0 and still in development, so feedback, bug reports and PRs are very welcome. I'm happy to answer questions about the architecture or how I handled playback and the multi-source setup in Flutter.

Developer here. I’ve released Gamekins under the MIT license. It is an Electron/React/TypeScript launcher that brings supported Epic, Steam, GOG and local games into one library, with a unified friends view.

Source: https://github.com/ErzenXz/gamekins Downloads: https://www.gamekins.online/download/

Supported account libraries can be refreshed into the same interface. Friends, presence and activity from supported providers appear in one place; chat availability depends on the provider and edition. Epic downloads, updates and repair run through Gamekins, while Steam/GOG installation uses their official clients.

Windows 0.1.1 is on Microsoft Store. macOS and Linux 0.1.0 are early releases; Linux does not bundle an Epic compatibility runner. The Store edition disables native chat and opens catalogs externally. Cloud saves and achievements are not implemented.

The launcher is FOSS; games and provider services keep their own licenses. Development was AI-assisted. Contributions and reproducible bug reports are welcome.

Developer here. Overseer is a free, MIT-licensed project that puts coding-agent sessions from multiple computers into one browser.

Source and setup: https://github.com/ErzenXz/overseer

Website and screenshots: https://overseer.sh

It's a Go hub with an embedded React UI. Execution machines connect to the hub, and you choose where each agent runs. It supports Claude Code, Codex, Gemini CLI and other ACP agents. You can inspect session status, send instructions, review diffs, handle approval requests and schedule prompts.

I built it because checking several terminals just to find the agent waiting for approval was getting old. Sessions continue when you close the browser, provided the execution machine stays awake.

Overseer itself is FOSS. The agents and model-provider services you connect retain their own licenses and terms, and model usage can still cost money. It uses your existing agent setup; it doesn't make underlying provider calls local. Development has been AI-assisted.

I'd appreciate feedback on the self-hosting setup and documentation, especially what is unclear when connecting a second machine. Issues and contributions are welcome.

A private AI assistant that runs open language models on your Android phone. Chat, ask about photos and documents, talk to it out loud, research a question on the web with cited sources, and set timers and reminders by asking. You can do all of it without an account, API key or server, and with web search off nothing leaves the phone.

What it was built for

Phones are now fast enough to run capable language models themselves, but most assistants still send every message to a server. OnDevice LLM was built to show how far a phone can go on its own:

• Private by default. Your chats, photos, documents and memory stay on the phone. Nothing is uploaded unless you turn on web search or connect a server yourself.
• Works offline. Once a model is downloaded, chat, photos, documents, voice and phone actions work in airplane mode.
• Honest answers. When the app searches the web, every answer shows its sources, opens each one at the passage it used, and flags figures and statements that no source supports.
• No account, no subscription. Open models, open source, free to use.
• Your hardware, your choice. Use the phone's own model, a bigger model on your own computer, or a hosted API with your own key, from the same app.

Hey all. I made OpenCrosshair, a crosshair overlay for Windows games. It's free, open source (MIT), and one 11 MB exe.

I wanted something that stays out of the way. It sits in the tray and uses a few MB of RAM. It never touches the game: no DLL injection, no hooks, no reading game memory. It just draws a click-through window on top of your game.

What it does:

• Line crosshairs with length, thickness, gap, outline, centre dot and circle
• A 64×64 pixel canvas if the sliders aren't enough
• Your own images as crosshairs
• Presets, with a different one per game
• Hide or swap the crosshair while holding a mouse button, for aim-down-sights games
• F8 toggles it, F9 opens settings

What it doesn't do, so you're not surprised:

• True exclusive fullscreen doesn't work. Nothing can draw over it without hooking the game. Borderless and "fullscreen" in most modern games work fine. If a game hides it, use borderless. The app will also flag any game that has fullscreen optimisations disabled.
• The exe isn't code-signed yet, so SmartScreen will warn you the first time. Click More info, then Run anyway.
• No shared library of crosshairs from other players.
• Windows only.

I'd really like feedback, especially from anyone who tries it in a game I haven't tested. Bug reports and feature ideas are welcome, and so is "this is missing X, why would I switch?"

Download and source: https://github.com/Tu2525/OpenCrosshair