An independent web browser that isn’t based on Google-funded code and has full keyboard control.

I want a Wikipedia for time and space. I want people to collaborate on a globe, marking territories of states, migrations of peoples, important events, temperatures, crop yields, trade flows. I want to pick which layers I want to see at one time. This sort of thing would give us a clearer, more integrated view of history, and show how connected we are all. A volcano eruption in Mexico led to crops failing around the world. New World crops led to an explosion of people in southern Chinap, a previously less inhabited place. A Viking woman met natives in present-day Canada and also visited Rome on pilgrimage.

Animated diagrams. Something like Visio or Omnigraffle, but with the ability to easily show messages flying around, instances appearing and disappearing, clusters moving, etc.

People usually reach for PointPoint or Keynote for this, which drives me up a wall. I’d rather have something that can directly create a video file or animated gif.

A simpler WebRTC alternative supported by major browsers.

Transfering video/audio between client-server or even p2p using NAT traversal is not rocket science. The problem with WebRTC is that rather than making one spec solving the specific problem at hand, it combines a bunch of older specs harping back to the 90s, but only partially implementing them (SDP, STUN, DTLS, RTP, SRTP, SCTP). Seriously it’s like some old telco like Ericsson having a wet dream thinking their old research turds are OK in 2020.

Each standard comes an RFC, but all WebRTC implementations in the wild (the 3-4 we have in the browsers), use an undocumented subset of each. To implement a WebRTC stack there is no definite way – look at existing code, read specs, test, fail, decode packets, investigate.

SDP just isn’t an ok way to transfer structured data (even XML would be better!). It also comes in flavors like “plan-b” and “unified” and neither is a sure way of supporting all browsers. Unified is apparently the modern way, but it’s amazingly verbose for no reason (the organisation of media around bidirectional “transceivers” is just absurd).

RTP is totally done in an age not even remotely like 2020. Lots of words and effort is spent on multicast, unencrypted transfers and imaginary A/V infrastructure that doesn’t exist.

The WebRTC as adopted by W3C is not a spec, cause rather than specifying anything, it’s more like someone took the original WebRTC C++ code wholesale and put the code into english words – and it’s not correct. It says implementations should do X, but in practice everyone does Y.

Two things.

1. An Emacs for the web – browser primitives, but with hooks and definitions that allow full user control over the entire experience, integrated with a good extension language, to allow for exploratory development. Bonus points if it can be integrated into Emacs;

2. a full stack language development environment from hardware initialization to user interface that derives its principles (user transparency, hackability) from Smalltalk or LISP machines, instead of from the legacy of Unix.

A mostly text-based shell Interface to my computer, which is not stuck in the last century: https://matklad.github.io/2019/11/16/a-better-shell.html

A trimmed down soft fork of firefox. Removing everything not necessary. Including everything marketing/saas related like sync, pocket, studies, random advertising, and so on. All the unnecessary web api stuff like “payment requests”, “battery”, “basic authentication”. Removing APIs that don’t need support anymore like ftp.

My goal here is to move towards something that doesn’t have behavior I don’t like (nagware and privacy leaks), and has a smaller surface area for security vulnerabilities.

The hardest problem with this is keeping it easy to sync up with firefox for the code that you haven’t deleted (using an old version isn’t an option because of security). My initial work on this (which I don’t anticipate having time to pick back up) was a system that stored “patches” in a version control system, were a patch was a directory that contained a list of files to delete/create. Diffs to apply. And scripts to run. This meant it was substantially less of a problem dealing with the inevitable “merge conflicts” since the system could be substantially smarter than a diff tool (e.g. instead of applying a regex once and making a diff, I could make a script that said “apply this regex everywhere”).

Something actually good for photo management and editing..

• RAW processing must be done on the GPU, as in vkdt, but like, write it in Rust, using wgpu or something. There is a raw loader in Rust already, use it
• don’t use imgui type things for UI noooooo just use GTK please and make it look nice and simple and GNOME-ish
• what is infuriating about Lightroom and every clone is that they treat exports as fire-and-forget. If you browse the library, it re-renders from RAW all the time, maybe using some kind of cache (badly). I do want to manage the JPEGs! In fact I want to see the JPEGs most of the time but if RAW exists for a photo I want a “redevelop” button to exist of course. And the discovery of the RAW origin of the JPEG must be really “bulletproof”, no matter how I move stuff around the FS as long as it’s below the directories the software knows about.
  • conversely, software like digiKam that aims to organize all the things is usually not great at RAW.
• why does everything suck over NFS. I store photos in NFS shares, please take it into account and access everything optimally. Don’t mmap the photos. Don’t use SQLite databases that don’t work over NFS. Argh.

Things I want and/or have worked a little on–that hopefully already exist and that I just haven’t heard of yet. :)

A proper client-server map tool for pen-and-paper RPGs, that supports quick sketching of environments or detailed art. Maptool is what we used to use at a friend’s house but it’s kinda clunky…the setup with a projector on the table was not though. :)

A personalized web spider rancher and search engine that seeds itself based on your browsing history. I’d also want to be able to federate it or allow collaboration with other individuals groups.

An open-source VR engine that isn’t Unity or Unreal (or webshit). I want something I can quickly prototype ideas on, like lovr, but that isn’t a walled garden and isn’t pushing me to using the current dominant model of game development tooling.

A self-hosted IFTTT alternative. I’ve already written one, and while an interesting step it isn’t what I want.

A self-hosted geocoding database. Something like Pelias but like I’m super lazy and just want it done somehow.

A good time-series database that can do explicit interpolation, extrapolation, and give ‘quality’ estimates to the data returned. I’ve worked on one or two of these, and everybody makes them too complicated (using elk or cassandra or Big Data shit or whatever) but also somehow manages to miss the usecase of an engineer who is taking signal measurements and needs to do reliable math on them. I just want Redis but for boring scalar and vector measurements that fit into a schema. I have a whole rant about this–and I’m also probably ignoring some solution that already does this!

A tool I can point at a directory of music and just say “sort out all of this shit and please remove obvious redundancies”. I have a bunch of files of music collected over two decades and the one thing I can guarantee is that: none of the ID3 tags are consistent, none of the filenames are consistent, none of the directory structures are consistent…I just want a program to go do the needful somehow. Machine Learning. GPT. AI. BIG DATA. idgaf.

A good replacement/rewrite of Balsamiq Markup that is documented for other people and runs on Linux and isn’t on the Cloud or some gnarly Adobe platform. I really miss this tool…I paid for it and I don’t really have any systems that run it easily anymore. :(

…there are a bunch more, but yeah.

Clean room ZFS reimplementation in public domain

I currently use MyFitnessPal for calorie-tracking and BigOven for recipe storage, and I cordially detest them both. They’re both buggy, slow, lacking a lot of features that I’d like to have, and “unmaintained” in that special SaaS way where vendors just stop fixing bugs or adding features once they have cash flow going. They also both cover like 80% of the same ground - BigOven has a way to calculate the nutrition numbers for a recipe but no daily calorie log, while MFP has no way to store recipes as anything more than a list of ingredients.

I want to replace the pair of them with a lightning-fast local-first app, but I just never seem to get around to it.

A CRM for personal relationships

Alternative code formatter for Rust, which works gently and cooperatively like gofmt.

rustfmt is a blunt tool with lots of edge cases that destroy readability on purpose, because rustfmt always chooses its own heuristics over any human input.

(e.g. gofmt preserves author’s decision whether a construct should be 1-liner or in multiple lines. rustfmt will explode expressions when it feels like it, and make spaghetti lines if it estimates they’ll fit).

Pie-in-the-Sky:

• An Oberon compiler targeting WASM that runs in the browser and emulates the Oberon System’s unique user interface.
• A total rewrite of sam.
• A reimplementation of Inferno using WASM instead of Dis and Limbo.
• An implementation of a small VM hypervisor exporting “standard” VirtIO devices, and then a small theoretically-runnable-on-bare-hardware-but-really-just-virtualized single-user operating system for it. Basically a modern reimagining of VM/CMS.

Actually Kinda Working On But Without Any Sense of Urgency:

• A ray-tracer in Rust
• A terrain generator, also in Rust, that outputs terrain in a format that can be consumed by the aforementioned ray-tracer
• A new text editor (seriously I have a problem)

Things That Are On The Back Burner But As Soon As Work Either Endorses Them Or Calms Down Enough To Give Me Time To Work On Them:

• An expert system shell in Python
• A super top-secret (in the conversational sense, not actually involving clearance) project that is going to be incredible but I can’t say anything more about right now involving extremely high-speed pattern matching
• Reworking the TCP reassembly portion of our product to be even faster (it’s already one of the faster ones out there, if I may be so bold)

An implementation of ‘/dev/compute’ to expose GPUs and similar coprocessors on 9front. The goal would be to drop all the legacy baggage around graphics in the interface, and simply expose the GPU cores directly to the OS, providing a way to pass the GPU a chunk of code and a block of memory, and letting it do its thing.

You’d get high performance compute then, and fast graphics could then be done via pure software rendering on top of that.

GPUs are getting sufficiently general purpose that this is likely to work well.

More automated security auditing tools for crawling public code repositories such as npm or crates.io, looking for anomalies and warning people if they use suspicious packages. I tried doing this myself but there’s other stuff I want to do too.

A biiiiiig pile of Linux+Rust graphics infrastructure stuff. Lots of low-hanging fruit to be plucked there still.

Something to explore the design space of “more minimal web”. Not quite as minimal as Gemini, probably something that uses HTTP but better/different text format and more minimal API.

Something to explore the design space of “human-writable encoding format better than JSON”. There’s plenty of machine-writable ones, and TOML is very nice for configuration files, but “easy to produce deep nested structures and less screwy than JSON” is still TBD.

Something that solves the same problems that systemd does but is more minimal.

Something that solves the same problems that pulseaudio does but is lower level.

Lots of other things.

Ah, the fun question :) I have several, but here’s my notes on the Todo/Email/Calendar of my dreams:

“Thought experiment 1: What if I dumped all my inbox into my current todo software (Todoist)? This would suck because it’s a crappy email client. Thought experiment 2: What if I dumped all my todos into Inbox? This would also kinda suck, because it’s missing a few features that a good todo should have…

That second one told me what I need: Inbox has “do not show me this thing until a date” i.e the first date something should be on your radar and Todoist has “item is due on this date”. For a good todo I need both.

Imagine a tool whose goal is “what am I doing in the future?”, with each item having a block of text associated with it, and a model that lets you send items to other people. Emails become new items in your “today” list, with a start date of right now and an unspecified end date. You can do the Inbox-style “put off this item until it’s actual usable date”. Most traditional todo items are either “do this by this date”, or “do this at some point”. The former have an end date but no start date, and the latter have neither date, and so need some other interface for exactly where they get put.

Other notes:

• You possibly have some local rules for tagging, prioritisation and other info added to incoming email.
• All calendar items can be a todo with a defined start/end date
• Being able to relate todo items in a DAG way (many separate graphs allowed, but no cycles within a single todo item graph) to allow for all forms of project sequencing is also awesome. “

Application scripting for UNIX.

What I want is the ability to treat application components like building blocks that I can address, control, and most importantly string together with a common data interchange between them, allowing me to compose complex customized workflows.

The Amiga did it with AREXX, Apple does it with the Open Scripting Architecture and AppleEvents, and Windows does it with Powershell and its several other more ancient mechanisms like OLE and even DDE.

But UNIX folks get this blank look when I try to talk about this and inevitably come back with “Uh. Pipelines?”.

Pipelines are amazingly powerful and I’ve built my career on UNIX so I’ll be one of the first to gush about the power of the “everything is a string of bytes” philosophy, but there are some things that are very hard to express with that one simple data structure.

a software for manipulating math equations with drag and drop and also can define your own algebraic rules like group theory.

This is more than just software, but I’d love a scanner on my fridge/pantry that I could scan all my food into.

Then I could see what is in the fridge, and, more importantly, what’s about to go bad, without looking through it.

It’d also make making a grocery list a snap, since a big chunk of my food is staples.

1. Less bloated and thought out alternative to Vim.

There are a few, but all of them for some reason choose to leave the same key-mappings, even when they make little sense. I think a lot of Vim defaults are there because of backwards compatibility. Kakoune would have been nice, except they messed up the workflow by going with the selection-first approach.

2. File annotation tool.

I am not sure what form this should take, but often I want to write notes about various pdf files I am reading and store the pdf and notes in the same place. There is papis but it does a bit too much in my opinion, and is more for storing meta-data (which is also important) instead of actual notes.

3. Terminal based email client.

There are a few, but they are a bit too complicated. mutt for example is designed to work with various other tools that you have to set up first. And then you have to set up mime extension handlings, and you need yet another software to hold your contacts in. Some simple (from users perspective) alternative would be nice in my opinion, even if less powerful.

4. A git-like tool (or a git like interface) to replace make

Right now with Make you have to declare dependencies between scripts within the Make file. I am not sure if possible, but would be nice to have a separate tool that handles dependencies. In this vision you would simply have some scripts that execute. The tool will then save dates about when is the last time the script was executed. And in addition would allow to declare dependencies via the command line (like tool add script1 script2). And of course other commands to display the DAG, list targets that are out of date, etc.

Where do I start.

STL Library. I have a whole ton of STL files from the various patreons I follow. I’d love to be able to collect and tag the various STLs so I can find what I’m looking for quickly. For instance, I’ve got one stl in one subfolder of a subfolder that is a dragonborn ranger. I may say one day, hey I need a ranger, well good luck finding that in “June Atrisans guild 2020/Dragonborns/dbr02.stl” or whatever. Tagging the individual models is the real trick here. Linking to multiple files is needed as some of them are split, and some even have pre-supported versions. I’d love to have a preview as well.

Same goes with Audiobooks. I have audiobooks in several places around my various drives. I’d love to be able to collect them into an app and catalog them in situ. Just allow me to gather metadata about the book, organize in the program and not have to collate my files.

As a feature of desktop enviroments: Focus follows mind.

3D Mechanical CAD that is good enough, like Kicad is good enough for electronics. I don’t necessarily need it to handle a 747 or car factory, but a kit plane or robot would be nice. The lack of a good foss cad package is what’s stopping me switching full time to linux, and why we have windows laptops at work to go with ubuntu desktops and why I have a personal macbook pro with the this-is-definitely-going-to-burn-me-one-day cloud storage Fusion 360. I would like to lose this mess completely and just live in Linux full time. I just think it’s still a bit to far over the critical distance from the pain points programmers have to be receive the attention required to solve it well. Maybe the 3D printer boom will help things along.

I want to work with Core War but have not time to do so.

A Namecoin-like software that generates HTTPS certificates, so HTTPS Everywhere can be backed by proof-of-work as opposed to the goodwill of the HTTPS Everywhere foundation

A new framework for cross-renderengine (OpenGL/Vulkan/Metal) and cross-platform (Mac/Windows/Linux) GPU-accelerated video effects. Basically the next generation of https://github.com/resolume/ffgl/.

A good binary file diff viewer, that is optimized for viewing flash memory, such as dumps of microcontroller memory.

Arrange the bytes in a grid, and ‘OR’ all the bytes in columns together. This will indicate if a single byte or pattern scribbled over the top of existing data.

Different colors for changes bytes with extra bits set or cleared. This is a good indication if you are looking at the aftermath of a partial erase, or a memory cell that is losing its ability to hold data.

Understand the block size, to indicate which blocks are changed / corrupted, which blocks are unchanged, which blocks are blank.

I’ve written the tool myself using ANSI color escapes, then piping through aha for HTML output. But it’s much slower than it should be.

https://luna-lang.org - I tried to get hired by them but we couldn’t find common points with my expertise areas unfortunately.

A non-Electron lean WYSIWYG Markdown editor with outliner features, with plugins support, for stuff like ASCIIMath, ditaa, ASCII UML diagrams, runnable code snippets, etc. (I know, I could learn emacs and org-mode… problem is, I am already fairly advanced in vim, and I don’t suspect evil mode has all the features I use…) Ideally with WordStar keyboard shortcuts.

A non-Electron GUI email client, with similar features as notmuch, with easy tagging of emails using emoticons/icons and instant filtering by tag combinations (ideally all icons visible at once) and allowing me to easily edit received messages so that I can keep only the crucial parts (but the rest of the whole email text could still be shown “grayed out”).

A git GUI allowing easy rebasing and splitting of commits via drag and drop on a tree visualization. Also with easy browsing of history and blame-digging (a.k.a. how did this bug/suspicious code get to look like it does now?).

A car driving simulator using Panini projection and Minecraft-like world editing, possibly on hex grid, shared in wiki-like way so that people could map their cities and train driving in them. With ability to represent non-flat roads, slightly uphill/downhill, up to steep narrow streets of Italian towns.

A microkernel-based OS working on Raspberry Pi 4 (possibly a set of missing drivers for Genode OS).

A REPL for Nim similar in power and features to OCaml’s utop.

Also, did I mention https://luna-lang.org?

I am not saying my dreams are widely shared, or good projects to take up… but I will answer the questions as stated.

Like spreadsheet, only to data-block-first. Multidimensional arrays come first, then they are layed out to show them best (unlike spreadsheets, where huge 2D sheet is primary, then arrays are kind of clumsily specified). Of course the ranges are also named; operations are likely to be a mix of how spreadsheets work nowadays, how normal code is written in Julia/Python/R/… and some things close to APL/J. No idea whether this can be made more useful (for someone) than just the existing structured-iteration libraries, maybe with a bit better output/visualisation code…

A DVCS that does not regress compared to Subversion. I want shallow (last month) and narrow (just this directory) checkouts supported on the level that the workflow that makes sense is just versioning entire $HOME and then sometimes extracting a subset as a project to push. Although no idea if the next iteration of Pijul will approach that.

A hackable 2D game with proper orbital mechanics take-off-to-landing (including aerodynamic flight with a possibility of stalling before landing etc.). Orbiter definitely does more than I want, but for me a 2D version would feel a nice more casual thing. And probably 2D has better chances of not needing Wine…

Writers have tools for sketching out and reshuffling the story; for proofs and for code documentation there is more weight on the notion of what depends on what; and sometimes one can reverse the dependency, or replace with a forward declaration; sketching and experimenting around all that can probably be aided by some kind of a tool, but no idea how it would look like. I guess it would have something in common with Tufts VUE…

A cloud-free IoT device framework/os. There’s so many cheap Chinese IoT devices out there that are just taking some off the shelf software and tossing it on lightly customized hardware. If there were some software that didn’t require a server to operate I have to imagine there’d be some that would pick it up and could slowly start to change consumer IoT from a privacy & security nightmare to what it was originally supposed to be.

Unfortunately, managed to finagle my dream project at my day job into existence so all of my mental energy has been going into that. (Which coincidentally, is making a cloud-focused IoT platform a little less cloud-focused.)

A semantically aware diff tool for Python that would work in tandem with git to aid refactoring work.

Instead of a load of line changes you would get eg. “moved function get_foo from bar.py to baz.py”

My dream web app would be an ability to pay open source maintainers some amount of money, whatever they feel is appropriate, to either ask questions to or even have them review an idea. My work, like most people here I would imagine, is entirely reliant on open-source projects maintained by often great people. However getting help in these projects is a nightmare. It’s either a mailing list that gets ignored, or a slack where its often the blind leading the blind.

I would love some sort of GitHub integration that says “for $500 one of the maintainers will look at your bug report and give you some ideas on why you might be seeing this problems”. I don’t want some sort of feature bounty, because I really like that new features are PRs. However sometimes I just need someone who has spent a lot of time with the software to take a look and let me know if I missed something, or if I need to make a PR where it might make sense to start. Or even to say “look what you are doing is terrible and we don’t recommend our software to do that”. I think it’s a missing link between traditional “enterprise support” and the current state of development.

Single-tenant SaaS software that scales to zero.

The software industry it too geared towards Google-scale. Self-hosted software is often PHP with some database that needs to keep running in the background. Backup is never mentioned in the installation manual.

If I had the time I would:

• Build a new kind of flat-file database that handles streaming updates and syncs to S3.
• Build a suite of tools that run on top of it and can scale to zero when not used.
• Some simple scheduler that is not Kubernetes.

An interactive shell for Oil :) It exists in Python and works well, but I don’t have time to translate it to C++, because of the issues laid out here:

http://www.oilshell.org/blog/2020/08/risks.html

All the algorithms are figured out:

• Oil Uses Its Parser For History And Completion
• Oil’s Parser Doesn’t Worry About Aliases and Prompts

I would either like help porting it, or I propose in the blog post it could be moved up to the “user level”

latest release: https://www.oilshell.org/release/0.8.pre10/

A window manager that I can save window layouts and “summon” them onto screens (this is important: my workstation has two heads, but I often work on my laptop in the garden and I want to have the same screens there).

I’ve got something well-gross “working” but it’s an unhealthy blend of autoexpect and stashing stuff in window properties that I can pick up in i3-cmd+xdotool+xwd scripts, a little x11vnc with a clipped window (left screen) and I think with better integration with the window manager I could do better, but I’m busy.

I’d like an operating system I can run on a laptop that I can:

• leave plugged in without the battery swelling
• run google hangouts, zoom, goto meeting, and whatever other video conferencing tools I need for work and family
• run slack
• run 1password (or another non-lastpass password manager)
• use a real package manager on
• program in ruby, go, java, python, c, etc without horrendous amounts of pain

I guess Ubuntu is my best bet? I still have yet to find a single linux-using coworker who can reliably join google hangouts video calls though (and I have no control over what video tool I use for work, but I CAN control my OS)

I still have not found any app for my notes. It should be a simple, fast and responsive, and beautiful, app that syncs my notes and works on Linux, MacOs, iOs and has a web-client. There are two million notes apps out there, why doesn’t anyone one of them get it right?

I’d really like a HTTP proxy inside Emacs so that I can navigate and edit requests and responses with all of the usual text editing tricks. It would be something like a cross between mitmproxy and magit.

At some point I’m going to create a “complex” software following the UNIX philosophy and using https://mkws.sh/pp.html to render to the web. Think it of as web interface for something like https://github.com/leahneukirchen/mblaze in case of an email client, or a web interface for something like https://adi.tilde.institute/cbl/ in case of an analytics system.

Full Stack (hardware to desktop environment) rearchitecture with low latency as the primary focus.

A programmatic diagram / graphic builder, like Processing that also lets you edit the diagram with a mouse, like OmniGraffle, and the source updates as you do.

I’ve had to draw diagrams with lots of repeating pieces in omnigraffle, which gets tedious to edit if you need to make a change that isn’t just a property change. It should be a function that can be repeated in any location, and then updates live everywhere when I change it. And of course most editors aren’t nearly as great at helping you select things - I miss being able to select e.g. all dotted lines, when I’m not in omnigraffle.

In the other direction, drawing lines between boxes, and making selections are much better with a mouse.

While there’s lots of examples of graphics languages, there are clearly some interesting issues about how to translate common mouse operations through into source. I’d like to dig into it, but really I just want to use it - I came up with the idea because I want to make more better diagrams about the things I’m actually working on.

A simple terminal task manager / time tracker with curses based interface with tagging, contexts, quick per-task notes and automatic priority calculation. TaskWarrior is close, but not really there.

A Peer To Peer strike app to coordinate workers along an international supply chain to perform a Machine-Learning optimized chessboard strike.

It would work like this: users can map the logistic of the supply chains (production times, travel times, buffers, salaries, contract types and so on) through a simple app. When enough people along the supply chain are on-board, a strike can be proposed. If enough people/organizations/unions agree, the app will call the strike and maximize the disruption on the supply chain and minimize the hours of strike, weighted by the vulnerability of the workers along the supply chain.

Gigantic open problems:

• how to fairly assess vulnerability across a global supply chain with a shared measure
• how to give rewards/punishments for groups/individuals that declare they will strike and then they won’t (both a problem of measurability and incentives)

Electron without electron. I can see the benefits that electron has had in terms of making desktop applications easier to build for a whole lot of people. But I hate the cruft and janky dependencies of NodeJS and the whole dependence on embedding chromium. I want a native desktop framework that has a good solid HTML/CSS interpreter and an embedded UI programming language which has more type-safety and doesn’t end up being a resource hog while being somewhat aligned with the language used for the lower-level programming of the application. It should compile down to a manageable static binary size. CSS, LESS and JS concepts of UI development work for people, people understand them so it has to be something parallel to that, but strip off all the extra cruft that should be handled by the underlying language that the framework is built in as well as exposing a GL context into the HTML/Views to render highly customized graphics / bypass the HTML rendering engine from the backend.

Also an out of the box CRDT (or similar) based embeddable database library with a gossip/viral-like syncing protocol for deploying desktop, embedded and mobile applications in places where connectivity is typically pretty bad and it’s easier to shunt data along through other devices until connectivity is stable.

An intelligent tiling window manager that can automatically re-arrange (on demand) based on the content of its windows (i.e. it would be aware where your browser / terminal has no significant content).

An open educational computing system with OS & compiler (+ simple hardware) that can be understood in its entirety by a single human being. http://www.projectoberon.com comes close, but a bit more modern and less archaic.

A reimagined web browser that builds on itself (i.e. starts with some SVG/PDF level primitives and creates higher level webcomponents with increasing complexity from that, all with a single coherent logical syntax (like s-expressions f.i.)).

A UI framework targeted to power users, like a modern age ncurses that isn’t restricted to the terminal with excellent support for extensible and scriptable apps, supports (but also limits) graphics, lot’s of focus on keybindings an layered VI-like modes.

Most of them are games, which, even if I could program, I will probably need help in other areas. Pikmin clon, X-COM style game for robbing banks, Theme Hospital like but for a whole town, some small puzzles…

As for software what I really want is to improve Haiku & Scryer Prolog projects.

csdoc

Like pydoc for C#

An alternative twitter in which all current posts are displayed on the screen at the same time, using a kind of tree layout.. (Well, I imagine bending it around visually to make a wheel layout, but that’s just display-level fluff.) All posted messages that start with “You know,” share a common root. When some starting letters are common to a lot of posts (in the last 24 hours?) then those letters are displayed with a larger font.

So, trending topics and hash tags and such would arise naturally from the medium.. so long as people put their hashtags in the front. (I thought about arranging it by longest common substring anywhere within the message, but I wasn’t sure what that would look like.)

If some really long common starting string exists, then the whole message is displayed on the home page in a large font.

Users would navigate by typing. If you type “you know,”, that’s a filter.. You’d only see messages that start with that.

A mono repo version control system: http://beza1e1.tuxen.de/monorepo_vcs.html

Something that makes writing/understanding very large amounts of YAML easy.

Bonus points if I can feed it something like… all Kubernetes options and available annotations and their types, and get some form of auto-complete and validation.

The acme editor, but for photo management. I’m still dreaming up what it looks like.

I currently use different software and services to get news in different topics:

• Tiny Tiny RSS, an RSS/Atom aggregator, with many subscriptions (single developer blogs, company blogs, news aggregators, comics)
• social networks (Twitter, Reddit, Mastodon)
• services to share links (this website, a private Discord server with friends…)

This is too much, I often miss important news or read things I could avoid reading at all.

There are also sources I follow that could be used to trigger actions automatically:

• release notes of software could be used to trigger rebuild and deploy to my servers
• new comic releases could be republished to some places

I realize that all this stuff could be assembled to build a framework that I could use to retrieve information from different sources, normalize it, sort it by importance, trigger actions. Some things I’d like to do:

• be able to programmatically add a source which produces certain types of content (this could be important daily news, an article on a topic, a tutorial, a comic, a software release, a message sent by someone, etc…)
• detect that multiple contents refers to the same piece of information, which happens frequently when following multiple news aggregators
• be notified of some important things like an uncommon topic becoming hot on different social platforms (e.g. related to world tensions, etc…)
• have a single front-end to follow news (Tiny Tiny RSS suffers from a few issues)
• centralize everything I’ve read in a single place (history on different browsers, social media links and likes, etc…)

I’ve looked at different software that could provide some of needed features (e.g. Weboob), but my conclusion is that I need to write specifications for a type system for applications to be based on, so that I could adapt existing libraries and front-ends to build a larger project (since I will never be able to build everything from scratch).

Recently, I’ve been thinking that for implementing content aggregators and convertors, the FAAS “paradigm” seems promising so I’m looking at knative although this project isn’t stable yet. Coupled with GitLab CI, I feel like I could easily deploy working code and finally start making something (it’s been at least 4 years I’m writing ideas around and talking about it).

A programming language that: a) Allows me to express side effects b) Compiles with a static syscall sandbox based on those side effects c) Is actor-oriented, with first class support for spawning actors in separate, isolated processes d) Doesn’t have a traditional main, but instead has first class, static dependency injection e) Has move semantics

Pony and Rust get super close to this in some capacity. For me this would just be a dream. It would give me what I love from Java (yes, I love things from Java), Rust, Pony, Erlang, etc, in one place.

If I had endless time I would build it.

A cloud storage solution that maintains xattr tags (for use in search, etc). Along with that, something like WinFS - a better way to query a filesystem

A replacement for APRS “SmartBeaconing” that makes more efficient use of bandwidth and provides more accurate projected positions.

SmartBeaconing is an improvement over “just transmit position every 5 minutes”, but in my opinion it’s both too complicated and not smart enough. The idea is to control the difference between the last-transmitted position and the current position using two basic rules: 1) transmit more often when going faster, and less often when moving slowly or not moving at all, and 2) transmit early when making a turn, if the product of the turn angle and the speed exceeds some threshold.

The problems with it are that it takes seven tunable parameters to do that, with different values required to get reasonable operation at different typical speeds (e.g. walking vs. biking vs. driving), and that both of its core algorithms are dirty hacks that only almost do what they’re supposed to. The speed part has a completely unnecessary parameter (the “slow speed”) that results in a discontinuity in the plot of distance-between-beacons vs. speed, the preference for beaconing at high speed biases projected positions, and the corner pegging mis-handles slow turns especially if it decides to beacon before a turn is complete.

My idea for a replacement is simple:

current_time, current_pos, current_vel = gps()
Tdelta = current_time - last_beacon_time
proj_new = current_pos + A * current_vel
proj_last = last_beacon_pos + (A + Tdelta) * last_beacon_vel
error = |proj_new - proj_last| + B * |current_pos - last_beacon_pos|
if ((error >= C && Tdelta >= Tmin) || Tdelta >= Tmax) {
    send_beacon()
    last_beacon_time, last_beacon_pos, last_beacon_vel =
         current_time, current_pos, current_vel
}

There are only five parameters here (A, B, C, Tmin, and Tmax), and not all of them necessarily have to be exposed to the user. A, Tmin, and Tmax have units of time; C has units of distance, and B is dimensionless. The idea is that a beacon should go out if:

1. Your position has diverged far from your projected track, in any direction (sensitivity controlled by C)
2. You’ve made a course change that will soon cause your position to diverge (sensitivity controlled by A and C)
3. You’ve traveled a long enough distance on a constant track that you’re probably in range of some new stations (sensitivity controlled by B and C)
4. You’ve done nothing but you need to beacon anyway to stay on people’s screens (Tmax)
5. And of course Tmin is a hard rate limit to prevent abusing the network.

The parts that I don’t have time for these days:

1. Find some GPS datasets from cars, bicyclists, and hikers and write a program to optimize the parameters over those tracks, minimizing sum of squared errors subject to constraints on allowable packet rate. Find plausible values, find out how sensitive they are, and find out if there are some that can just be hardcoded and hidden from the user without doing much harm.
2. Build the algorithm into Direwolf.
3. Convince Kenwood or someone that they should use it.
4. (actually 1b). come up with a name.

A good desktop app for storing, analyzing, and annotating chess games.

While there are plenty of things that clear the bar of functionality, there are none that are really nice to use; their user interfaces tend to be cluttered, cryptic, or both. Most of the necessary components – PGN parsing/writing/annotation, UCI engine interface, move validation and board generation – are even available under open-source licenses, but I just don’t have the time to pick out the right set and wire them together.

I’d love a web version of Mutt. Lean as the original, with the support of the browser’s supported file format.

Some sort of native widgets library that actually works cross-platform (GTK, Qt, Cocoa, Windows), works well, and is still maintained. Electron doesn’t count.

File synchronization service with on-demand local file loading.

I always wanted a network file synchronization mechanism where all files, directories, symbolic links etc. are locally visible but the data of the files is only loaded on demand. There would be a command (and context menu item for graphical desktops) to load and unload specific files or directory trees for the local system. Once loaded locally, it should transparently and continuously synchronize the files with the server.

With traditional remote disk mounts there’s no local storage space wasted, but usage experience suffers from the network dependency. File synchronization services are more pleasant to use since all files are local, but waste locale storage space. This would combine the advantages of both.

An open source distributed cloud that with a ledger to value storage and processing.

An open source and distributed app store for apps that I could single click install on my home server that’s a member of this collective cloud.

A feed reader that can process thousands of feeds and filter up the news I find important or read worthy.

A software for documenting workflows in pseudocode that works really well.

A distributed store-and-forward network protocol to replace email/Dropbox, but with API hooks for negotiating real time P2P sessions (slack/hangouts/etc), and community moderation (a la mastodon server federation) to address spam.

Bit late to the thread, but I just want to let this out.

I want a graphical code editor, one that is not electron, has extensive plugin support (so that it can even be called a “light IDE” with the right plugins installed), is cross platform, and most importantly, is cross CPU architecture.

Sublime Text does all of those except for “cross CPU architecture”, and honestly ever since I got into ARM computers I didn’t even genuinely feel the need for something that can replace it, but as it stands now, ST runs a bit slow with qemu-user-static on my PBP, and nothing much can hold its place. I use vim for the most part, but I need something graphical for better productivity.

A note taking and set organization app specifically for comedians.

A simple usable RADIUS server that takes a tiny config file, if any. Aim for 60-300 seconds from downloading/building the binary to running service.

An IRCd with the same goals.

Both in a compiled language.

A website with data and charts. Take data series and plot them on the same charts, easy to remix existing datasets and plot new information on other datasets. So you can point out e.g. political events with commit rates in open source projects, etc.

• a serious graph file system, ideally on NFS. Eg, I want to CD into the same folder from many locations. I know perhaps something similar can be built via (Sym)Links but i feel they just aren’t the same.

• An event pipeline of all events, in my life and in the world. I want to correlate wake up times with external temperature and news and school closings, etc etc

• a whiteboard software that is actually similar to the real thing

• a graph architectural decision tree that shows selections and alternatives and trade offs and allows to compute quantities across traversals

• something like a “Kirchhoff circuit laws” builder that computes maximum theoretical uptime/latency for distributed architectures