* Manual for safe digital life

- In Spanish, https://www.incibe.es/ciudadania/formacion/guias is not terrible, but not great either.

* Easier self-hosted communities
** NixOS Pubnix
** Nice mailing lists

- GH-style user/organization creation
- Every user/organization can create mailing lists
- Mailing lists have a web UI
- The mailing list UI can be completely customized to look like microblogging, blogs, comment systems, etc.
- max n messages over m days feature. n=0, don't send me emails. n=1, send me a digest every m days. n>=2, stop at n-1, then wait until the m period is over to send me a digest.

** Federated real-time communications using open protocols https://github.com/alexpdp7/frtcuop

* HTML/JS only browser engine

This is likely: https://github.com/txtdot/txtdot
Also:

#+BEGIN_SRC bash
chromium --headless --dump-dom mastodon.social/@foo/12345... | w3m -T text/html -dump
#+END_SRC

- Use an existing JS engine to implement a browser that can parse HTML and execute JS, but which has no concept of graphics
- Could be used to implement a text HTML browser that can access the modern web
- Extensible and scriptable, to generate "article mode" scripts, scrapers, and "API proxies" (or redirect to farside.link, etc.)
- Proxy

* Touch controller/meeting controller/desktop shortcuts + calendar

https://mutedeck.com/ is basically this.

- API server to control Google Meet (mute, etc.)
- Use a USB gamepad to mute in videoconferences, etc
- Small webapp for touch interface in phone
- Displays and alerts on upcoming events
- See https://github.com/alexpdp7/meet-controller

* Parallel execution framework

See https://github.com/alexpdp7/scripts-py-libs

- A tool to run stuff such as CI builds which need sophisticated parallelization
- Create differently sized resource pools (for CPU-bound tasks, "API"-bound, etc.)
- Local execution of workflows on a workstation, remote execution on a CI server
- Handle task dependencies and artifact passing from parent to child tasks
- Capture stdout/stderr of tasks, allow viewing in realtime
- Timestamp stdout/stderr for crude profiling
- Implement a CI system on top?

Some parts could be implemented with OpenTelemetry.
For example, piping command output as OpenTelemetry logs.

** Process nanny

See [[https://github.com/open-telemetry/opentelemetry-specification/blob/main/experimental/trace/zpages.md]], [[https://gitlab.com/etke.cc/tools/ttm/][ttm]] for Matrix.

- A program to manage long running processes
- Acts as a bot in IRC, email, Slack, etc. posting when the job is done, providing updates, etc.
- Starts an xterm.js to watch the output

* Better "smart TV" experience

** Browser cursor control

- Adapt web pages so you can browse them using cursor keys.
- Use a "powerful" computer as a Smart TV with a simple remote

Vivaldi's "spatial navigation" supposedly does this, but chokes on D+.

** Run Android on powerful x86 inside Kodi https://github.com/supechicken/waydroid-androidtv-build

* Simple web proxy

- Proxy + web frontend that does ~chromium --headless --dump-dom $URL --virtual-time-budget=10000 | w3m -T text/html -dump~
- Perhaps pluggable DOM manipulation

* "Cloudy" Gemini client

- Multidevice bookmarks, certificates, etc.
- Perhaps "personal" web frontend

* Terminal mail client
- Easy set up of common mail accounts (perhaps using mbsync, notmuch, mu, etc.)
- Sane defaults
- Markdown email (write email as Markdown, send as plain text + HTML)
- Probably https://jmap.io/ can make implementing this easier

WIP: https://github.com/alexpdp7/epistle

Perhaps use mblaze

* Databases in text markup documents

- Embed queries of tables

See https://github.com/alexpdp7/pandocsql https://github.com/alexpdp7/pandoc_datalog

* Userland WASM Linux distro

- Bootstrap a Linux distro to run on WASM
- Should be able to run as a non-privileged user, installed in the user's home directory
- Focused on userland programs, not a full OS
- Should be able to run on non-POSIX filesystems
- Could replace Docker/containers for developers
- Similar to https://github.com/WAVM/Wavix

* Binary "upstream" package manager

https://github.com/alexpdp7/ubpkg/ (also discusses some alternatives)

- Package manager that downloads published binaries on the Internet
- Manifests describe how to fetch binaries (e.g. from GitHub releases)
- Manifests are just files that can be referenced by URLs, or be contained in repositories of manifests

* Extensible lightweight markup language

- A language similar to AsciiDoc...
- But with a well-defined AST
- Complex nested lists
- Styling of code blocks (highlighting, user input, replaceable...)
- See https://github.com/jgm/djot / https://github.com/opendevise/asciidoc-parsing-lab/
- Helper for "prose linters".

* WOL tool

- Can be used from browsers/apps
- "Network-transparent"

Probably Home Assistant can do this.

* Streaming DB

That's probably https://github.com/MaterializeInc/materialize , but it's not OSS.

- Simple relational database
- Can act as replication target of other databases
- Supports a limited SQL subset that can be easily reasoned about functional dependencies
- Can stream efficiently the results of an SQL query (e.g. keep a query running and receive new/modified rows)
- Supports efficient replication of a subset of a database (initial checkpoint + streaming or batched updates)
- Functional dependencies could be used to create materialized views *and* indexes

* CRUD framework

- https://github.com/alexpdp7/v2f
- https://github.com/alexpdp7/zqxjkcrud

A completely declarative SQL CRUD framework

- CRUD definition is done through SQL objects (schemas, views, etc.)
- Permissions
- Row auditing
- Multiple components
  -  Server-side HTML frontend
  -  REST API
- Commercial frontend for design

* Key escrow for everyone

- Easy-to-use key escrow/secret sharing
- Provide emergency recovery of passwords, keys, 2FA, etc.

* SQL2

See https://github.com/EvgSkv/logica, [[https://prql-lang.org/]]

- A new language that compiles to SQL
- Handles RDBMS differences
- Makes queries composable (e.g. declare a query object, then add paging/sorting, for framework usage)
- Declarative join via foreign key constraint names
- Better ordering for code completion (e.g. FROMs first)

* Easier own-your-Fedipub identity
** ActivityPub reverse proxy

Run the reverse proxy on your domain so you can "duplicate" your identity on your own domain
** ActivityPub SaaS kit

(Maybe Yunohost)
* Statically-typed AST transform-friendly language

- A Haskell/Rusty language, but with GC and nice compiler errors.
- First-class support for AST transforms- both one-off (apply this transform to the source code and commit the change) and ongoing (define AST transforms to run as part of the compilation process).
- Maybe such language would never need reflection, so refactoring would be very safe.

* SQL Query tool

- ipython notebook style interface
- Backend + multiple frontends
  -  HTML/JS Frontend
  -  Curses frontend
  -  Native GUIs frontends
- Smart join completion

* News aggregator

- Basically news.google.com (grouping of the same news across different publications)
- But with "regeneration" of headlines (e.g. replace headlines with "extremely descriptive" headlines)
- And smart filters for topics (e.g. I'm interested in TV series, but not realities)

* Presentation tool

- A tool to edit reveal.js-style slides
- But also record and do basic audio editing
- So it can help with timing/pacing, and even generate a nice video
- Optional mode to limit slides to "hero images" and a reduced number of words per page. See [[https://www.nytimes.com/2010/04/27/world/27powerpoint.html][We Have Met the Enemy and He Is PowerPoint]]
- Teleprompter/good speaker notes mode

* Scalable personal cloud

This is basically a hybrid of https://linuxcontainers.org/incus/ and https://proxmox.com/en/proxmox-virtual-environment/overview

1..n node VM/container hosting platform

- ZFS storage (use https://github.com/marcan/takeover.sh for easy set up of a ZFS mirror root system)
- Automation ready (Ansible, Salt, Foreman, etc.)
- Tools to create VMs from cloud images automatedly. See [[https://gitlab.com/libosinfo/osinfo-db/]], [[https://github.com/alexpdp7/cloud-run]], [[https://github.com/virt-lightning/virt-lightning]]
- Monitoring friendly
- Apt for single public IP
  - Integrated DNS/DHCP
  - VPN interfaces
  -  Reverse proxies

* Better "frontends" for console programs with OpenTelemetry support

https://github.com/alexpdp7/rust_tracing_starter

* Ecosystem for mountable e-ink displays with wireless charging and magnets

- For example, a small e-ink tablet that you can attach to a wireless charger with magnets in your fridge, with an always-on display of a shopping list, and a microphone to add new items.
- The tablet is completely optional, can be replaced by a different device, etc.
- How to have flexibility, such as different form factors and still provide a pleasant and pretty experience? (e.g. can you attach displays of different sizes to the same fridge and have it usable and look good?)

* C64 Roguelike