- It's a personalized newsletter for you

- All data aggregated from sources around the web

- News, weather, newsletters, social media posts, reddit, youtube, etc. all appear in your digest.

- Launching a mobile app as well now but this will be slightly different than the web app. It will use AI to automatically prepare your daily digest based on preferences/settings you give it during onboarding. Each day when you wake up you'll receive a notification of digest being ready, and it will contain all the content you care about for the day ahead (meetings, weather, health data, commute data, news, etc).

I'm also automating more stuff around bookmarks management -> I used to manage an awesome list as a repository on GitHub for myself and over a couple of years there are relatively many stars on this repository. However I lost interest in maintaining this repo manually as I prefer to save my bookmarks on Shaarli. I'm coding a CLI tool to automate the work of syncing my shaarli links to my public "popular" (+500 stars) repo at https://github.com/SansGuidon/bookmarks

Myself and other users complain a lot about the "native" Plex -> Ombi watchlist integration being broken, I coded some sync tool to workaround the app malfunctions, by using Ombi, Plex and TMDB (The Movie Database) APIs and ensure Ombi is always up-to-date based on Plex watchlist. This works very well and allowed me to put a stop to the complains from my family members :-D

I'm also automating most of my email/linkedin interactions thanks to userscripts. And I keep automating more of the work I do around Cloudron, which is a very fun and stable platform to manage apps on VPS without the pains.

https://github.com/addpipe/webcam-tester

Live demo @ https://addpipe.com/webcam-tester/

Is there a cadence for these threads? I had in mind to "be prepared" to post in November's with what I'm working on, but I expected it to come around on the 15th (mid-month).

What I'm working on:

- skuilder - (skill builder) - https://github.com/patched-network/vue-skuilder - an AGPL framework / toolkit for SRS++ based interactive tutoring systems

- https://letterspractice.com - a low cost, hopefully high quality early literacy acquisition app, targeting ages 3-5.

- https://flutor.app - an app to learn the flute

(The proprietary apps are built with the toolkit).

I've struggled to pitch or articulate the vision here, but my latest pithy attempt is: scaling self-actualization by mechanizing the nested loops described by Anders Ericson's 'deliberate practice' - Inner loop: individual learners maximize their skill uptake velocity and performance peak by adhering to domain specific best practices - Outer loop: domain specific best practices get refined according to innovation or serendipitous discoveries from the inner loop (eg, someone is observed to beat out prior best practices)

As mentioned, I'm flat-foot posting here, so the pages aren't all prepped. https://flutor.app/dbg and https://letterspractice.com/dbg show some of the innards. Not linked, but I'm especially fond of https://letterspractice.com/dbg/juggling - the premise here that as child practices the letters, the letters exemplify the principles of effective practice in alliterative skill domains (juggling Js, batting Bs, flossing Fs (it's hard ok?))

All-in-one router/nas/firewall/adblock/app server (each piece optional)

Declarative and reproduceable as it is built off of NixOS, but administered through a UI, so the user doesn't have to know this.

All state managed in a backup bundle, so it can be hosted at home or in the cloud.

Goal is to have a box you plug just like a wifi access point into your modem, follow a simple web-based installation flow, then you are running a personal cloud.

Website is self-hosted by HomeFree, but installation instructions are very out of date, which I'm working on right now. There are now installation ISOs that I will soon add a link to.

https://reader.manabi.io

I recently added FSRS (besides also having Anki integration). Now I'm working on replacing the need for reviewing flashcards by having reading activity automatically mark flashcards (current and future) as reviewed, so that you can get many of your reviews in just by reading native materials that interest you instead of sacrificing most of your study time to contextless flashcard grind.

I'm also working on a manga mode using a new manga OCR tech I have licensed out of academia that is ahead of state of the art alternatives.

This project now sustains my full-time focus.

Open Source Vacuum Robot firmware

https://github.com/codetiger/VacuumTiger

OpenRun runs as a web server, which does GitOps driven app deployments. You can currently deploy apps on a standalone machine, on top of Docker/Podman. Working on adding support for deploying on top of Kubernetes. On Kubernetes, OpenRun will replace your build jobs (Jenkins/Actions etc), CD (ArgoCD etc) and IDP (Backstage etc). The same declarative config which works on a standalone machine will work on Kubernetes, with no YAML to maintain.

I've done this with C++ in the past, but ran into substantial friction with the CMake toolchain, specifically w.r.t:

- cross-platform compilation with large dependencies (vcpkg ports)

- running multiple compiler chains in the same build step

That second point is necessary if, for example, there's some AOT asset processing work that uses a native tool, and you're building for web. Expressing that some targets should use the emscripten toolchain while others should use the native toolchain, and interleaving between them, was a mess. TBF, I haven't done that with cargo or build.rs yet and it may prove to be equally frustrating.

Other features:

- undo/redo using a stack of swappable states

- serialization to disk (native) and LocalStorage (web) with some integration tests in progress but I am not satisfied with the correctness of my implementation: I want to *guarantee* that all information is preserved round-trip, but I also want a Patek watch.

- OBJ, GLTF, GLB models are loaded as "blueprint scenes" which are distinct from the "world scene." I made this distinction at the type-level because "scenes" are groups of entities that use newtype IDs (`LightId(u64)`, `MeshId(u64)` etc.) as primary and foreign keys to refer to each other, and I wanted to make it impossible for an entity in scene A to hold an ID for an entity in scene B. Instantiating a blueprint requires creating new IDs for every object.

- W.I.P. Alpha rendering, depth sorting, overhauling the material system to support multiple shaders (tough) that may be compiled after the engine itself (even tougher, a lot of runtime dynamic state and schema validation stuff), physics, scripting - oh yeah!

- Scripting using JS on both web (runs in browser itself) and desktop (uses a packaged JS runtime `Boa`) but Boa doesn't perform well on desktop in debug mode so I'm exploring other options.

[1] https://puredata.info

[2] https://msp.ucsd.edu/techniques.htm

[3] https://mitpress.mit.edu/9780262014465/the-audio-programming...