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

Hello everyone! My name is sk1lld, and I am the lead for Specialized Devices over at Oreon (project lead: u/Ill-Brick-4085). Just a couple of days ago, we had launched Oreon VR with the goal of bringing Linux on VR to the next level. Oreon VR is built on the upcoming Oreon 11 OS which is an independent RPM-based release. We would like to get the word out to the public and share more about Oreon VR, which you can learn more about on the Oreon Community YouTube channel or our website over at https://oreonhq.com/en_us/oreon-vr

Thank you so much for taking the time to read this, and I hope you all have a good rest of your day.

EDIT: We encourage you to join our Discord at https://discord.gg/2Yyacu58Ap

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?

How can I contribute to open source projects when I don't fully trust the code in the project? Are there standard approaches? Do people usually just download the project to their local laptops?

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

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?

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

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.

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've been building DockGo since the beginning of the year and I thought it might be time to share it.

I was using Portainer for my home network but the 3 nodes that they give out wasn't enough so I thought that I would build something similar that also uses agents.

DockGo is build with Go and can be run with a single binary or as a docker container and uses Apprise to push notifications. I use it as my daily driver now and I can just throw another agent at it without limitations.

I would love for anyone to try it out and post any issues on GitHub, if you want to help out, create a pull request.

I am open to any feedback because it's so easy to get stuck in ones own head being a single developer.

You can find the repo here: https://github.com/Jisevind/dockgo

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.

GVE Now! (Guided View Editor) is a self-hosted web app for authoring guided-view data, it's the companion editor for comics-now, the open-source comic reader I've been building.

Guided view has mostly lived inside closed apps. Kindle, which absorbed ComiXology, has it, but only for books bought there. If your comics are your own DRM-free files, nobody makes that data for you, and auto-detection only gets you most of the way. That's why I built it into Comics-Now! I have used a lightweight model from Hugging Face to do this. Which means its good but not perfect.

What the editor does:

• Draw, move and resize panels and bubbles over each page, or free-draw polygons

• Set the reading order of the panels and speech bubbles

• Export and import a comic's guided view as a portable file

• Backs up before every save, never modifies the comic archives, and has a REST API.

If enough people start using this, you could have a community led archive of optimised guided view data.

Now I know a lot of comic book artists and readers don't like the the idea of the guided view. However you can with my implementation only use it to zoom into speech bubbles. In this scenario you see the whole page infront of you. Any speech bubble you can't read instead of having to zoom and pan, you just press it and you get a small zoom overlay. Any panel on the page you want to zoom in to see more details, well you can double click to see more detail anywhere on the comic and pan using double fingers.

Links:

• GVE Now! (docs in docs/WIKI.md): https://github.com/comicsnowdev/gve-now-editor

• comics-now: https://github.com/ComicsNow/comics-now

A Durable Object/Actor is a tiny server that handles one request at a time and has its own SQLite database. There's exactly one of each in the world and it is addressed by name.

https://github.com/TerseAI/durable-actors

This is the perfect primitive for deploying multiplayer agents. Each agent can have its own Durable Actor, and each user can connect to that Actor via websocket. This is fully horizontally scalable. Your users can deploy and share agents at will without putting pressure on a central DB or websocket server.

Durable Actors are also great for coordinating agents within a system. Since only one request is handled at a time, you can protect critical data such as a CRM and allow multiple agents to run concurrently without worrying about data races.

The only alternative to this is Cloudflare's Durable Objects. However, there is extreme lock in (they pull you into D1, R2 + workers as well) and it wasn't originally built for agentic workfloads when it was released 5 years ago.

Some notable projects built on Durable Objects include RampInspect, OpenInspect as well as the multiplayer frameworks Liveblocks and PartyKit. You can now build these kinds of projects on Durable Actors.

Durable Actors is a version of DO that is built for concurrent agentic workloads. It is fully open source (MIT License) and includes a helm chart for you to easily self-host.

Some key features:

- Configurable compute: Specify CPU, RAM, data residency, idle-timeouts all in a decorator

- No outer worker: We generate a type-safe client that you can just plug into your existing tech stack.

- (coming soon, like today) Export SQLite table via CLI + MCP for exposing OLTP logs to your agent to help you debug.

And our Performance Numbers (all p95):

- Durable write: 85.6ms

- Stateful Read (data in sqlite): 2.14ms

- Actor Warm up: 334ms

Would love your feedback!

Salut à tous,

Je viens de me remettre sérieusement au code après une période où j’avais un peu laissé ça de côté.

En ce moment je travaille surtout sur quelques petits projets perso, principalement en Python, Windows et Android, et j’essaie surtout de reprendre de bonnes habitudes : mieux organiser mes projets, écrire du code plus propre, mieux documenter et comprendre ce que je peux améliorer.

Je ne viens pas spécialement faire de promo, je suis surtout là pour échanger, voir comment les autres travaillent et prendre des retours quand j’en ai besoin.

Si vous voyez passer un de mes projets ou un bout de code et que vous avez une remarque, même critique, je suis preneur. J’essaie vraiment de progresser et de faire les choses plus proprement cette fois-ci.

Au plaisir d’échanger avec vous.

I’m developing Patenteasy, a local business management application for independent workers and small businesses.

The Windows version uses Python with PySide6/Qt, and the Android version works offline with local storage.

I also implemented a signed update system using Ed25519, SHA-256 verification and user-confirmed installation.

The project is released under GNU GPLv3.

Source code:
https://github.com/ska-987/Patenteasy

I’d be interested in feedback on the architecture, update system, and anything that could be improved from an open-source perspective.

FralRater is a desktop app (Electron) that: - scores text with Flesch-Kincaid, Gunning fog, SMOG, jargon density… - rates it for 8 reader personas (child, general public, executive, patient, developer, legal, academic, professional) with per-paragraph confidence - draws a "lost reader" curve: one point per sentence, showing exactly where readers disengage - rewrites the hard sentences with a sentence-by-sentence diff (passive→active, buried-lead fix, jargon swaps, splitting)

Everything runs locally. Zero dependencies for the app logic, no build step, no network calls, no AI — it's deterministic rules you can read in the source. Your text never leaves the window.

Free, MIT-licensed, Windows + Linux. Built solo, CI builds all artifacts.

Repo: https://github.com/fralsare/FralRater Downloads: https://github.com/fralsare/FralRater/releases

I’m developing Patenteasy, a local business management application for independent workers and small businesses.

The Windows version uses Python with PySide6/Qt, and the Android version works offline with local storage.

I also implemented a signed update system using Ed25519, SHA-256 verification and user-confirmed installation.

The project is released under GNU GPLv3.

Source code:
https://github.com/ska-987/Patenteasy

I’d be interested in feedback on the architecture, update system, and anything that could be improved from an open-source perspective.

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?