These are things I want to work on, but also bait other people into solving for me.

These are mostly sorted by my interest; ideas on top of the list have more priority to me than ideas at the bottom of the list.

If you have interest on any of those ideas and you want to influence my priorities (I would prefer to work on stuff that also interest others), please let me know.
(I would use [[https://en.wikipedia.org/wiki/Score_voting#Advocacy][the immanent method voting system]] to judge other's priorities.
If you send me a number between -1 and 1 for any ideas in these lists [or ideas outside the list!], I will add all numbers I receive and use that to estimate external interest.
If you send me a list of ideas you are interested in, I will consider those votes with the value 1.)

* Make digital life safer

- [[https://github.com/vida-segura-online-es/vida-segura-online-es][vida-segura-online-es]], a resource that provides reputable resources oriented to people living in Spain.

** Key escrow for everyone

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

** Mutual encrypted backups

- Software to do mutual encrypted backups over the Internet

* Better access to news https://github.com/las-noticias for Spain
* Easier self-hosted communities
** Regulatory compliance and self-hosting
** Document hosting providers

- https://community.exoscale.com/documentation/platform/billing/#pre-paid-billing Exoscale is cloud-y, but has pre-paid payment so overuse only results in suspension
** Database of self-hosting packages

In progress: https://github.com/alexpdp7/selfhostwatch

See https://github.com/alexpdp7/alexpdp7/blob/master/INTERESTING_PROJECTS.org#self-hosting-solutions

- Track versions so you can determine update track records.

** Research alternative networks
*** Research if https://yggdrasil-network.github.io/ + https://opennic.org/ can self-host systems such as YunoHost without a public IP, nor spending money on DNS, etc.
** 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
** 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
** 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

** GitHub Actions/Pages-powered Planet

- Perhaps https://github.com/exaroth/liveboat-github-runner

* [[programming/the-content-web-manifesto/README.md][Simpler web]]
* Responsive handwriting

- A tool that helps create handwritten documents that adapt to different screen and text sizes
- [[https://alexpdp7.github.io/responsive-handwriting/][Manual proof of concept]].

* Typing database

- A database of keyboard layouts.
- You can query how many keystrokes are required to enter a specific character.
- A database of characters used when writing in specific languages.

This would be useful to decide which characters to use for programmatic syntax.
(That require few keystrokes for most users, but collide as little as possible with punctuation, etc.)

* 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

** Streaming service planner

- List shows you want to see, see a calendar of releases by service
- Prototype: https://github.com/alexpdp7/strsvcp

* 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

* Databases in text markup documents

- Embed queries of tables

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

* 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

** Layer FastAPI on top of the Django ORM to add APIs to Django applications.

* 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)

* 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

* 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?)

* 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

* Tvheadend XMLTV export and metadata restructuring

* Extensible lightweight markup language

See [[misc/document-formats.md]]

* 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

* Collaborative database of places where you can play arcade games

* SQL Query tool

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

* 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

* 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

* Better "frontends" for console programs with OpenTelemetry support

https://github.com/alexpdp7/rust_tracing_starter

* 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.

* "Cloudy" Gemini client

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

* WOL tool

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

Probably Home Assistant can do this.

* C64 Roguelike