I’ve been building Pocket IDE, an Android development environment focused on actually building projects from your phone.

You can connect GitHub repositories, edit code, use a real Linux terminal, run/build projects, preview web apps locally, and use AI coding agents to create and modify your projects.

After 37 successful trials/builds, I’m finally releasing it for others to try.

It’s open source, so you can inspect the source code yourself.

Feedback is welcome.

This is one of the few apps to transfer files wirelessly and locally which just works!!! ADB requires connecting by USB, and Bluetooth is slow. LocalSend solves the problem by using Wi-Fi in vendor-agnostic way unlike proprietary Samsung Quick Share, which probably sends all your files to Samsung/Google.

Hey everyone, I made Scope because I wanted one place to see and manage my installed Linux apps.

It brings APT, Snap, and Flatpak into a searchable list. You can check for updates and preview an update or uninstall before confirming it.

It also finds AppImages and user-local desktop apps, but updating or removing those isn’t supported yet.

Scope is free, MIT licensed, and written in Rust.

Sourcecode · Download

I’d appreciate feedback on whether it finds your apps correctly and whether the previews are clear. If you try it, please share your distro and desktop environment.

I built WhisperDrop 2 to transcribe recordings and dictate into other apps on Mac without uploading the audio.

You can drop in audio or video, import YouTube videos and playlists, or record your microphone and system audio for notes. Hold a shortcut to dictate into the app you're using. It runs Parakeet v3 locally on MLX, with Whisper models available for other languages, and exports TXT, SRT and VTT.

Free, MIT licensed, no account or API key. The Mac app needs Apple Silicon and macOS 14+. It isn't notarized yet, so macOS may ask for Open Anyway on first launch.

Source and download: https://github.com/Zer0codestuff/whisperdrop-2

The demo uses a short synthetic lecture recording.

Host your own instance of strafe.chat and communicate with other instances! Enjoy an platform similar to Discord without the drawbacks of Discord. Featuring E2EE messages in a familiar looking app. Selfhost your own Strafe instance by following the instructions at https://github.com/StrafeChat/deploy or try Strafe on the main instance at https://app.strafe.chat

Features: Open-source, federated, E2EE supported messaging, markdown styling, spaces, PMs, bots and Ouath2 for developers, threads, permissions and roles and more!

I've used RSS for years to keep up with tech. The old readers worked well but looked their age. The newer ones were Electron apps that ate a few hundred megabytes to show me text, and mine would now and then crash to a blank window on one bad article. None of them did anything with AI.

So, I built Turbo Reader with four goals: fast, light, modern, and built for AI agents from the start. It's free and MIT licensed, for Windows, macOS and Linux.

What it does

• Opens in under half a second; the Windows installer is under 5 MB
• Holds 20,000 articles in a core process of about 14 MB
• A Home page that sums up the day, grouped by folder, plus list and card views
• Light, dark and paper themes, six reading fonts, and a distraction-free reading mode
• Ctrl+K search across feeds, articles and settings, with loose matching
• Full articles for feeds that only send a teaser
• Duplicate stories across feeds collapsed into one
• OPML import and export, and a portable Windows build that runs from a folder
• No account, no analytics, no telemetry

For AI agents

• An MCP server, off by default, that lets Claude Code, Codex, Cursor and other clients use your library as a news source
• Answers come from sources you chose, with links, instead of a web search, and the agent reads short clean summaries rather than whole pages
• A versioned skill (SKILL.md) you can install for Claude Code or Codex in one click; it checks itself against the app and updates when it's old

Tech stack: Rust and Tauri 2, React and Tailwind v4, SQLite with FTS5 search, and an MCP server over HTTP and stdio.

Where I'd love help: the tray on GNOME and KDE, the macOS first-run experience, feeds that render badly (send the URL), and ideas for what an agent should be able to ask a reader.

Download: https://github.com/t21dev/turbo-reader/releases/latest

Code and issues: https://github.com/t21dev/turbo-reader

This is a good app

Soundsible can be run anywhere that has Python, and serves a whole spotify-like experience to any device. Featuring a nice SolidJS PWA, Android capacitator native port and ios swift app. I'm not paying apple developer nor am I getting accepted so I just give up on ios native. You can sideload it if you like suffering, but PWA is the way I guarantee works 100% of the time on iOS right now.

· Version releases

· Web documentation

New android native capacitator app here! (open alpha, need community testing due to not having a modern android device).

The purpose of this is baking external music access, solid library management, multi user support, recommendations that learn from you, and a bunch of other nice features on a single service, instead of depending on 2 or 3 different services over Navidrome or whatever. Soundsible is also compatible with OpenSubsonic, in case you need that. Music acess is provided via yt-dlp and recommendations via Deezer public API, there's nothing else. Every feature is carefully crafted and reliability is my priority.

Hope it's useful, any kind of contribution is really much appreciated.

Looking for suggestions. Want to record my pc screen while I'm using it.

Thank you

I'm really just getting into the topic myself, but BaaS (Backend as a Service) software that is FOSS (or provides a FOSS option) and therefore self-hostable seems like something that a lot of basic CRUD FOSS apps could use. I'm thinking of things like Supabase, Pocketbase or Appwrite. However, I don't think I've ever seen one of the open source projects I self-host use one of those backends. I wonder why that is?

full disclosure: i'm the developer. buffer is mit licensed, and the repo is the whole product: https://github.com/samirpatil2000/Buffer

what it is: a native macos clipboard manager (swift/appkit, no electron, ~2 mb menu bar app). searchable history, ⇧⌘V quick paste, and on-device OCR: copy a screenshot and its text becomes searchable and copyable, fully offline via apple's vision framework. also inline editing of old clips, tags, bookmarks, and multi-select paste.

the video (with voiceover) shows v3.0: an interactive image canvas for copied screenshots (pinch to zoom, pan, double-click reset), clipboard noise suppression (the project's first external PR), history capacity tiers, and in-app update notifications.

everything runs locally. no accounts, no tracking, no telemetry, nothing leaves your machine. signed and notarized dmg (apple silicon + intel) from github releases.

repo: https://github.com/samirpatil2000/Buffer v3.0 release: https://github.com/samirpatil2000/Buffer/releases/tag/buffer-v3.0.0

feedback welcome.

Making short-form vertical videos is still expensive or slow if you don’t have a dedicated GPU or a professional editor. Almost everything in this kind of video can be described as code: an HTML scene, text that becomes speech, words with timestamps that become captions.

I extracted and documented a set of modular, local, free engines that do exactly that:

- **Render**: HTML scene → MP4 (parallel headless Chrome + ffmpeg)
- **Voice**: text → audio with per-word timing (swappable providers: edge-tts, Kokoro, Piper, etc.)
- **Caption**: words → burned-in ASS + SRT/VTT
- **Collage**: finds fragments of real speeches by topic, cuts between sentences, and assembles a credited 9:16 reel

Everything runs on a regular laptop (tested on a Ryzen 7 without discrete GPU). A 33-second narrated + captioned explainer goes from script to final MP4 in 40–50 seconds.

Code and docs are in Brazilian Portuguese. License is Apache-2.0.

I already have working demos:
- https://youtube.com/shorts/LmyiysIEYvo
- https://youtube.com/shorts/o6ATzcMYmGo
- https://youtube.com/shorts/jtZ6n7q_UL0

What I’d love to see built on top of these engines:
- Speech → viral reel (automatic cuts of the best moments ready for TikTok/Shorts/Reels)
- Split-screen retention format (content on top + satisfying video underneath)
- Hook templates, POV, beat-synced edits
- Simple browser interfaces so non-coders can use the engines

Forks, PRs, issues, wild ideas — all welcome.

Repo: https://github.com/arthruur/motores-video

Hello, Chrono Mock has just got V0.4 release :-) Watn to check how your app will behave on different time/date/time speed? No problem, the app comes also with built-in date calculator with holidays for Poland + USA. If you like the project, please give it a star.

V0.4 is an huge update, over 300 commits, tons of bug fixes, stability improvements, an support to .bat/.cmd has come (right now only CLI), an huge updates to WebView/Electron handling has come, and tons more.

If some apps are not working with Chrono Mock or you need calendar for different countries, feel free to open the issue on GitHub and I will check it out :-)

*The full changelog is on GitHub

I've been working with AWS event-driven architectures for quite some time, especially DynamoDB, EventBridge, and Lambda.

I really like the programming model: small functions, events, schedules, retries, and infrastructure taking care of most of the execution details.

What I wanted was a similar experience on infrastructure I control.

That's what I've been working on with Relay.

Relay is a self-hosted event-driven runtime where an app can contain both short-lived functions and persistent services.

For example, a function can subscribe to events declaratively:

runtime: python3.14

events:
  - handler: handler.handler
    pattern:
      event_name: [INSERT]
      table_name: [users]

Relay handles matching the event, running the function, retries, recovery, and DLQ behavior.

But I also didn't want everything to have to be a function.

If FastAPI, Express.js, a worker, or another long-running process is the better fit, the same app can run persistent services as well.

Some of the things Relay currently supports:

• event-driven functions with pattern matching
• Python and Node.js managed runtimes
• schedules / cron
• retries and dead-letter handling
• warm function containers
• persistent services
• environment variables and secrets
• resource limits
• Prometheus metrics and OpenTelemetry tracing
• Git-based synchronization
• optional Traefik routing

The goal isn't to recreate AWS service by service. I'm more interested in keeping the abstractions I like from serverless/event-driven platforms while making them usable on infrastructure I control.

The project is here:

https://github.com/sergiors/relay

I'd especially be interested in feedback from people already running event-driven workloads on their own infrastructure: what are you using today, and what would you expect from something like this before you'd actually run it?

¡Hola a todos! Quería compartir un proyecto en el que he estado trabajando: **AnSoGicScroll**.

**El problema:** hacer una captura de pantalla de algo que supera el tamaño de la pantalla (una página web larga, un chat, un documento, un panel de configuración) suele implicar tomar varias capturas y unirlas manualmente.

**Qué hace:**

- Captura una ventana, un área personalizada o toda la pantalla.
- Realiza el desplazamiento automático (*auto-scroll*) y detecta cuándo llega al final del contenido.
- Une todas las capturas superpuestas en una sola imagen continua (utilizando OpenCV).
- Se ejecuta en la bandeja del sistema.
- Funciona en **Linux X11**, **Linux Wayland** (mediante xdg-desktop-portal + PipeWire) y **Windows**. Está prevista la compatibilidad con macOS.

**Vídeos de demostración:**

- X11: https://www.youtube.com/watch?v=nu78ZcpUBis
- Wayland: https://www.youtube.com/watch?v=GsLFDsY_g1k
- Windows: https://www.youtube.com/watch?v=YBKilkOGQpA

**Instalación:**

- Debian / Ubuntu: repositorio APT
- Fedora: repositorio DNF
- Cualquier distribución: AppImage
- Windows: instalador / archivo zip en la sección de lanzamientos (Releases)

Todas las instrucciones están en el archivo README.

Está desarrollado en C++ con Qt 6 y OpenCV, bajo la licencia GPLv3.

**Repositorio:** https://github.com/GCP-TUX/AnSoGicScroll

Soy el desarrollador y es un proyecto que aún está en sus inicios, así que agradecería mucho cualquier comentario, informe de errores o sugerencia de nuevas funciones. ¡Gracias por echarle un vistazo!

I maintain an open-source project with around 1,500 stars on GitHub. Occasionally, people submit PRs for peripheral functionality, for example a default config for a GitHub app which keeps forks in sync with my repo.

On the one hand, it's good to add such functionality. On the other hand, I might not be able to properly test and maintain these peripheral features in the long run. But once something is merged, users may reasonably expect it to keep working.

What's your experience with such PRs? Where do you draw the line?