path: root/IDEAS.org

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

* PiKVM Screenreader

- Modern KVM products use HDMI USB capture cards and Linux gadget support to capture a display and send mouse/keyboard events to a headless machine.
- PiKVM already has an [[https://docs.pikvm.org/ocr/][OCR feature]] that can capture an image region and run OCR on it to paste it as text to the clipboard.
- Same principle could be used to build a screenreader for BIOS screens and the like.

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

** Own your email or stable communities for email

Make it easier for people to get a domain and own their email address.

- Comparison of methods to do this (e.g. bring-your-own domain email providers, with prices, ease-of-use, etc.)
- Make it easier to create long-lasting communities that provide such services (ISPs, banks, insurance companies, governments, professional associations?)

** 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
- Make NAS devices have a simple backup process to send encrypted backups to someone of your trust.
- You enter a code on both NAS, configure disk usage, and you get remote backups that can't be read on the target.
- You can speed up the backup via sneakernet.

* 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
** 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.
** Research confidential computing so that users can run private workloads on shared systems such as tildes

- [[https://discuss.linuxcontainers.org/t/confidential-computing-support/25765/2][Does not seem to be there yet]]
** 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.

Alternatively, research https://public-inbox.org/README

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

- Integrate an XMPP server (such as [[https://esl.github.io/MongooseDocs/latest/tutorials/Jingle-SIP-setup/][MongooseIM with mod_jingle_sip]]) with SIP systems (such as Flexisip).

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

* [[programming/the-content-web-manifesto/README.md][Simpler web]]
** Gemini mirror

- A Gemini server designed *only* for proxying http content as Gemini
- With virtual hosting support

Configure httpd with:

- [[https://httpd.apache.org/docs/trunk/content-negotiation.html#negotiation][multiviews]] so httpd can serve .gmi files
- Any cgi or whatever you want to generate dynamic content if needed

Then the mirror makes requests to httpd requesting Gemini content.

Your static site generator can do:

- /foo.gmi
- /foo.html

httpd will serve the HTML for /foo for regular browsers.
The mirror requests /foo to httpd, which returns the gemtext.

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

* Real-time data on websites
** Non-completely OSS options
- https://github.com/MaterializeInc/materialize
- https://github.com/confluentinc/ksql
** Full idea
- 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
** Basic implementation
- Service that provides an API to interact with PostgreSQL logical replication
- API that creates a publication and a subscription for a table with a filter
- Libraries to interact with the service and create HTMX (or similar) components that live update.
* Videoconference based on document (not screen) sharing

- Microsoft 365 and Google already offer this, but with drawbacks (Google's is Chrome only, I haven't managed to do this with free Teams).
  Miro and others are similar.
- Instead of screen sharing, everyone's browser opens a shared document with some synchronization (e.g. selected slide)
- With documents that allow collaborative editing, meeting participants can edit live
- Could start with just pdf.js sharing and document location synchronization

* Tool to replace all text files in a repository with a link, to migrate from a Git forge to another place without breaking links
* Code review tool

- It runs automatic validation on unchecked commits continuously, adding git notes with the result
- Provides a UI to approve individual commits
- For validated *and* approved commits, it implements a merge queue that works on a per-commit basis.

* 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

** Test SteamOS/ChimeraOS for streaming service usage.
** HDMI-CEC "fixer" daemon, see https://johnlian.net/posts/hdmi-cec/
** Streaming service planner

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

** Discussion for TV series

- Shows only messages from people who have not seen more episodes than you

** External metadata

- A separate foo.x file that you keep next to foo.mp4 with the metadata (movie name, IMDB id, season, episode, etc.)
- Makes things reliable and separate from opaque media databases

* Next generation Linux distributions
** 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
- Maybe using https://github.com/yomaytk/elfconv
- Maybe https://git.sr.ht/~zamfofex/guix-wasm

** Make traditional Linux distributions declarative

- A container image builder that can convert JSON-like declarations of an OS into container images
- https://github.com/bootc-dev/bootc that handles running the builder and rebooting when system configuration changes
- https://github.com/systemd/particleos

** Rootless Nix/Guix

- https://nixos.wiki/wiki/Nix_Installation_Guide#Installing_without_root_permissions
- https://guix.gnu.org/manual/devel/en/html_node/Invoking-guix-pack.html
- https://hpc.guix.info/blog/2025/03/build-daemon-drops-its-privileges/
- https://github.com/DavHau/nix-portable/issues/66
- https://github.com/nix-community/home-manager/issues/3752#issuecomment-1566179742

* [[https://github.com/alexpdp7/tojson/][Standard configuration processing layer]]
* Databases in text markup documents

- Embed queries of tables

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

* Agenda

- An API-based daemon that keeps a list of date, string[] tag, string message, int ordering, internal id
- Ordering is -1, -2, -3, ..., -n, 0, 1, 2, 3, ... n
- Negative ordering items are done, 0 is in progress, positive are todo
- Processes that poll external sources (calendars, org-mode, ticket trackers, etc.) and add elements to the list.
  For processes that poll sources without stable ids, the daemon does similarity comparisons for identity
- UIs show the list by ordering, allow reordering, filtering by tag
* 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)

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

* Ultrasound small transfer utility

- Uses sound to transfer small pieces information (e.g. text for distributed copy and paste)
- Desktop app, webapp (for other people's computers), Android with "share" functionality

* Tvheadend XMLTV export and metadata restructuring

* Geeky surveys

- Surveys are defined using a Python DSL
- Survey reponses are JSON-like
- Frontends such as a terminal UI, completely keyboard-driveable HTML, etc.

* 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
- https://github.com/IsmaelMartinez/teams-for-linux wraps the Microsoft Teams app and adds MQTT support to control mute and other features
- https://playwright.dev/docs/api/class-electron maybe Playwright can manipulate the Slack Electron application
- https://github.com/eclipse-mosquitto/mosquitto/issues/3421 for the glue
* 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

* Shell

- Interface for programs to declare their interface; types of arguments, etc.
  (This would enable things such as automatic tab completion, etc.)
- Richer interface for output, such as allowing programs to state that they have bound to a port and serving an HTTP interface.
  This way, `top` could have a "rich interface" (HTML/JS is not ideal, but it exists).
  You could likely integrate a web browser into a terminal program nicely this way.

* 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