Assorted ideas

Things I should maybe probably do for this website:

• Join a few webrings and clubs.
• Make a list of friends' websites. And/or make a blogroll with OPML.
• Add a "Fun" section with games and experiments.
• Move website from Netlify to self-hosted Nginx.
• Host a webmentions receiver!
• Host an OpenHeart service.
• Move self-hosted parts of the website from Docker Compose to Podman and/or k3s.
• Fix issues discussed in ShellShark's Good Sitekeeping page, especially date formats, selection color, and dark/light themes.
• Add tags to the Atom feed.
• Possibly redo the CSS to use less CSS Grids.
• Add CSS for nice printing display.
• Try out Djot.
• Make a few RSS-only posts (...unless I already did? 😁).
• Add width and height to images, enable lazy-loading.
• Consider a No adblocker detected box.
• Explore the 100 83 things you can do on your personal website article on James' Coffee Blog.
• Make an /ideas page Done! 🎉

General, you can probably steal the idea:

• Reply to a blog tag/challenge; say about pointless facts 5-space tabs; umbrellas, one of the IndieWeb Clubs/Carnivals (e.g. IndieWeb Clubs Movie),
• Another installment of the "Exploring the Small Web" series.
• Post about origami, cooking, and similar hobbies.
• Follow up on Audio CD music post.
• Story by the album: write a short story inspired by a music album.
• Reflections on the division of "why"/"what"/"how" that often creeps into project descriptions.
• Thoughts/research on ways of supporting artists without relying on copyright.
• Ways in which open-source is superior to proprietary, by design.
• From my notes: "'Brute force, dumb luck, and sheer talent'—I just like the title 😂"
• A few drafts sitting around: importance of open/accessible culture, the best online community I've been part of, Christians in Free/Libre/Open art and software, the operating system I wish I had.

TODOs, rather me-specific:

• Part 3 of the Bugs Done Quick recap. Uh..
• An article about Project: World, my toy programming language.
• Lessons learned from my ongoing Programming course/workshop.
• Something about Docker Compose-based VPS management.
• An article about my first NPM package!

"Resetup" is an ongoing list of projects I would love to make part of my day-to-day computer system at some point.

These include:

• Any modal editor. Whether that's Kakoune, Neovim, or Helix.
• A tiling window manager. I've heard good things about Niri.
• A Git alternative, with better merge conflict support and nicer interface. Perhaps Jujutsu or Pijul.
• A DNS alternative! GNUNet's GNS looks good, hope it's ready at some point 😁
• A different Linux distribution. Probably Nix, given that I'm currently on Arch, and can't fall much lower. 🥲
• Something with Plan 9 or the *BSD-s.
• A better notetaking system. Currently using TiddlyWiki thanks to the excellent syncing of Val Packett's TiddlyPWA, but I do hope for better.. Something with bookmarks and people especially!
• A cooler personal budgeting system. LibreOffice Calc is great, but Paisa or a different double-entry ledger might be good to experiment with.

In my country, and coincidentially in my room, most curtain rails use a 2-track system compatible with GARDINIA's GE2 curtain rails.

I would like to improve my embedded/hardware development skills by devising a mechanism to automate opening and closing a curtain making a curtain move back and forth.

So far, have a general concept of a mechnism using motors and a fishing line, but would need to prototype it to see if there's enough space for the fishing line inside the rail.

Neocubes are small, spherical magnets sold as a toy. They can be assembled in a variety of structures, from "strings" to "rings" to "planes", and bind to each others in at least three different ways, reminiscent of sigma, pi, and delta bonds in chemistry.

It would be great if we had a decent software package for playing around with simulated Neocube magnets. The one GitHub repository called neocube_simulation is implemented in MatLab and is not realtime 😅

As the person currently responsible for getting slides ready for church every week, it's probably worth checking if I can build something better than the Google Slides document we currently use.

Key features needed:

• "Presenter" view, to be able to control the slides on a screen without distracting people with mouse pointers.
  • Easy-to-use list of slides, including title slides one can easily jump to during prayer / sermon / etc.
• Automatic multi-page layout for displaying longer text passages.
• Readily-available list of songs that can be pulled up as needed.
• Theming with CSS (because I'd rather not deal with Google Slides Masters again).

There already exists church software doing some of that, such as Risen Media or MatSongProjector, but building one's own sounds more fun 😁

I've contributed a tiny bit to OSM, but I would love to do more.

MapRoulette seems like a decent place to start.

Split off from the other list of website ideas. I currently have a fully-static website, but once I move things over to Nginx, I would have the opportunity to slowly make parts of the site more dynamic—integrating OpenHeart counts / webmentions / comments, and so on.

But doing that has me wondering—why even keep parts of the content static? I could turn the website idea on its head, and serve completely different versions of it every time its requested! 🎉

Things like:

• Changing sidebar colors (but probably keeping it constant per-IP).
• Tracking popular pages and making links to them larger/smaller depending on traffic.
• Letting visitors shape parts of the website by voting between colors, sizes, and so on.
• Changing summaries and page titles randomly, so there is no single "canonoical" title of an article.

I might be going too far, but... I haven't seen anyone else even go near that kind of dynamic website, so it might be cool to be unique. 😁

Got an old Huawei device...or two that could get upcycled and maybe used as Linux phones. I've researched and experimented a bit, but I'm currently 0-to-2 on devices successfully rooted 😅

It all started with me experimenting with modding TeeWords way back, wondering if it could be made easier (say, with Lua), and later even contributing a few fixes and a dynamic automapper for DDNet.
At the time, I took notice of the netcode, which consisted of taking a snapshot of what the client should be able to see, then sending them the differences.
Later I read about GGPO and their rollback netcode, in which instead of sending updates in positions to other players, the server sends a list of players' inputs and each client applies them to an earlier state to get the final state.

And at that point, the three ideas merged into one:

The way I imagine it, each game could be split into 4 parts:

• The game logic WASM blob, which takes in a list of client inputs and the current list of objects—things like players, pickups, and so on—and spits out an updated list of objects. This has to be stateless for rollback netcode to work.
• The server-side WASM blob, which takes in the list of objects and spits out which client should be able to see which object. This is the snapshotting part I so liked about the TeeWorlds netcode.
• The client-side WASM blob, which takes in the list of objects and spits out a list of drawing commands. Looking at GGPO, playing audio would also be handled here, but would need special treatment to avoid cutting in and out when rolling the state back. (Probably includes image/audio assets.)
• The map, which is just an initial list of objects, including player spawn positions. (Probably includes image/audio assets.)

The game engine would then have a server-side component which supports loading and saving maps, and exposes a network interface for the client-side part of the engine to connect. The client-side part of the engine would download the game logic and client-side WASMs, then download the current state of the world, and start simulating local player inputs on top of it, while syncing them back to the server-side part.

I imagine editing maps could be implemented as an extra version of the client-side WASM. That would mean that unlike TeeWorlds it could be possible for an administrator to edit the map while a match is being held, with only a slight impact on bandwidth use.

I have not considered how objects should be encoded/serialized, either on-wire or on-disk. In fact, the whole concept of "object" as described above is really vague, and probably won't work well with all compiled-to-WASM languages.

Note that I'm not involved in game development these days, so this idea would likely go unimplemented.

For a recent website project, I needed to offer a decent WYSIWYG editor for Markdown files.

However, all the ones I found follow the same design:

1. Parse the Markdown into an abstract structure (AST)
2. Show an alright editor for that abstract structure
3. Convert AST back to (possibly different) Markdown

The trouble with this approach is that the user is no longer writing Markdown, they are writing an abstract structure that happens to convert to Markdown. If the editor does not fully support a feature of Markdown (and they probably don't, considering that Markdown can embed arbitrary HTML), the user is unable to use it; which wouldn't be the case if you just made an raw text editor with a preview on the side.

So, hear me out: what if we could have the best of both worlds: a Markdown editor which lets you edit the Markdown source, except it doesn't scare you away with it?

You open the editor. What you see is the preview. You can edit parts of the preview, and since they are text, your edits go straight through.

But the moment you touch the markup; say, you go left of a heading, you find your text cursor between the markup symbols, so, in the middle of a few ###-s for the heading example.

To bold something, you can select it and use Ctrl-B(/Cmd-B). But if you type ** before and after the text, you would also get the same bold! You are editing Markdown, after all.

The idea is still missing details around when markup symbols are shown or hidden. There might need to be modes where they are shown without moving the rest of the text, as well as modes in which the editor is just glorified syntax highlighting. Drawing it out, similar to the Max Krieger's Glue Comic might be best.

EDIT: Apparently, this has been implemented by Obsidian and SilverBullet already! 🎉 I'll have to play around with their implementation and see if there's more to improve on the idea... ✨

Less of an idea and more of a research direction. There are already projects which deliver some form of "filesystem, but I can synchronize it between my machines", but I haven't found one that has all the things I want:

• Sync personal devices mainly—less problems around simultaneous changes.
• Peer-to-peer—should generally work even if my home computer is offline.
• Offline-first—should work when I'm on a train.
• Filtering—should be able to limit what gets synced to each machine. (e.g. my phone doesn't need a copy of all my code)
• HTTP/WebRTC frontend—to be able to build extra web applications on top, e.g. for notetaking.
• FUSE-based filesystem mounting—better performance when tracking thousands of files, less likely that an edit is not registered by the network code.

Syncthing delivers similar functionality; I'm worried about the performance and filtering if I use it, but I could see this idea morph into a fork of Syncthing. Braid looks extremely interesting. Tahoe-LAFS is related, except it works at an even grander scale and provides tighter security bounds. The Coda file system might be promising; I would have to use it to see where it falls apart.

A local or self-hosted search engine which scrubs pages you've bookmarked or have visited, then browses pages they link to (directed by keywords and topics you care about), and finally lets you search the whole list of pages it's indexed.

For a bonus, add a fallback system for queries it fails to find locally, so it can look them up in friends' instance of the program.

Apparently, there's YaCy which sounds similar.

This is for the LISP enthusiasts.

Aeons ago, the Developer sat down and created the whole world. Using the "REPL" function to evaluate code, the Developer created all other Functions: the "Define" function which lets you create new objects, the "Draw" function which lets you display things to the screen, the "Explain" function which defines help texts and info boxes, the "Time" function which lets you stop or even reverse time. The Developer then used those Functions to create the rest of the world, including the non-player characters, the items, the damage system, and so on.

Now, as the player, you start with just one tool: the "Help" function, plus the ability to move around and explore the virtual game world that the Developer has made.
In a metroidvania fashion, you gain additional tools as the game progresses and you solve the various challenges it throws at you. For example, there is the "Inspect" function which lets you see the code of any object (or character) you come across. The ultimate goal? To find the "REPL" function at the core of it all, guarded by the final boss and final puzzle.

Then, you would have all the tools the Developer used to make the game. Ultimate power to modify the game any way you want. What new world would the new Developer create?

Not the first to think about it, as evidenced by this r/ProgrammingLanguages thread.

But, still, imagine if the programming language understood the whitespace around operators as a way to set their precedence:

1 + 2*3  =  7
1+2 * 3  =  9

Potentially, that could also be used for left-to-right vs right-to-left precedence?

2 ^2 ^3  =  64  # (2^2)^3
2^ 2^ 3  =  256 # 2^(2^3)

Bad idea, but it could be worse! (E.g., operator precedence based on types, so you e.g. have * implemented for (+, +), and + for (u8, u8), similar to how BNF parsers are written.)

It might be possible to make a Wayland server/proxy, which shows all windows underneath it as individual tabs.

Jury's out on whether that is a better idea than just using Haiku or not. 😂

If you thought the previous idea about a tabbed Wayland proxy was impractical and bad, here's a worse one!

Both Chromium and Firefox use a similar architecture of splitting browsing contexts into a separate process for sandboxing purposes.

...that means that the "shell" which draws tabs, deals with bookmarks, and potentially manages storage (cookies) and navigation is virtually the same thing, except with a different backend beneath.

So why not make the backends swappable? 😂

(Because it's a huge effort to bridge the gap between WebKit and Gecko, I would imagine.)

That way, you could configure sites which only work in one browser to open in that browser engine, while still having only one history and list of bookmarks!

Note that I'm not involved in game development these days, so those ideas would likely go unimplemented. Also, my Luanti experience can be summarized as "played with a friend for a few months and made one mod for the world" 😅

Luanti games generally suffer from a lack of overarching goals for the player, so a lot of the ideas are somehow related to that.

"Circular" progression system

Instead of having one ultimate goal, say, defeating the final boss, what if the game had multiple "tracks" on which the player can progress, with each tracking strengthening the next one on the "circle"/"spiral" of progression.

For example:

• You want to fight the hardest in-game boss, but you need a better weapon.
• You want a better weapon, but you need to mine deeper.
• You want to mine deeper, but you need a reliable food source.
• You want a better food source, but you need to explore the world for it.
• You want to explore the world, but you need to fight monsters on the way.
• (And, just like that, we've gone full circle!)

It'd be even better if decorating could be made part of the progression at some step.

Entities with goals

More of a what-if than an idea. What if the "monsters" the player comes across don't exist only to attack the player, but have some goal of their own. Perhaps elves want more trees planted. Or perhaps dragons want less riches outside of their hoard. Regardless of the case, perhaps they destroy the player's buildings if and only if the player gets into their way.

Ancient structures

Scatter various half-destroyed structures around the world; say gazebos, houses, and so on. Then, let the player repair one abandoned structure by scavenging materials from other similar structures—but don't let them make those materials themselves.

Once the structure has been rebuilt correctly, it can provide some utility to the player, such as being a portal, or a crafting station, or even a weather control panel. Perhaps all it does is make the nearby area less hostile.

Inspiration: Rare roof restoration uses material from Japan's Imperial forest.

Underworld monster empire

Instead of monsters spawning "out of thin air" all across the world, what if each area had an ominous cave opening where the monsters come from. The player can then venture into the cave, and eventually get to the end of the cave, defeating the local boss. Once said local boss is defeated, monsters in the area should generally weaken, making it more hospitable.

Then, to tie all the caves into an overarching "empire", make the end of each ominious cave lead to a deeper, even harder cave, with its own boss. And so on, recursively (since each cave "below" can be "responsible" for multiple caves "above"), until one reaches the final boss, somewhere far, far, deep below.

Limited entry portal

Imagine a portal with two ends, A and B. Each end has a limited number of stored "uses"; perhaps each starts out with just one use.

When you enter from side A, you take one of the uses with you in the form of a "ticket" (for the route B←→A).
If you re-enter B with the ticket, that ticket will get used up in place of one of B's "uses".
However, if you traverse the way back to A on foot, you can bring the ticket with you, and use it to charge up A instead.
...or something like that. Need to draw it to make more sense of it.

That way, making portals that can be used by many players would require more work than just setting up a portal once. Also, the work needed for making a portal is proportional to the distance it covers.

If the output of a Transformer-based language models is the probability of a given sequence of words/tokens occurring, perhaps we could use it, directly, to highlight hotspots in the text that could be grammatically incorrect?

In fact, we could probably differenciate wrong forms of words, omitted words, and unnecessary words by exploring the probabilities of phrases with replaced/added/removed words near each of the hotspots.

This feel like a saner way of using a language model than prompting it and hoping it produces the right result.

Silly idea based on the notion that location, form, and presentation can raise the value of a good:
Make a tiny food stand selling nicely-cubed slices of watermelon on a paper plate with a fork in a park.

Given how cheap all three ingredients are, even if you add ice packs and refrigerator bags to keep watermelon cold, it feels like the whole operation can easily be made profitable.

Unsure if I'll end up attempting that. There are VAT and food safety regulations I would have to navigate upfront, and I need to gather the courage to sell things in public.

...still, could be a fun idea to show up to a picnic with friends like that, and skip the whole selling part 😁

Blockchain-based virtual currencies tend to run into scaling problems because they have only one chain of checksums that needs to incorporate all transactions.

...So, why not get rid of the constraint and allow anyone to run their own chain, similar to traditional trusted timestamping authorities? If you have one timestamping authority sign the current latest checksum of another, you can even have ways of detecting timestamping authority reversions!

No clue how to turn this into a virtual money protocol that is robust in the face of double-spending. But I feels it's a really simple solution to the whole "consensus" thing that almost nobody is pursuing.