Technology
This is a list of new and/or upcoming technologies that I find interesting, cool, exciting, etc.
This list is not really in any particular order, other than that I've tried to group generally similar/related technologies approximately closer together. In other words, the list is not sorted by how cool or exciting the tech is.
Of note is that other than LoRa, everything in this list is open source (to at least some degree).
Of further note is that this list does not include my own software/"tech".
Guix  linux os software
Guix is both a purely functional package manager and system configuration manager, as well as a Linux-based1, Lisp-based2 operating system (Guix System). Guix System is often described as a "meta distribution" (explained below), but it can also be thought of as "Nix(OS) done right" - for example, rather than a janky custom language, it's built in Guile, an implementation of the Scheme programming language. That means that you have all the power of a full, well-defined programming language (such as access to all of its libraries, and all the performance you'd expect from a language that compiles to native code), without losing the advantages and conveniences of a domain-specific one (since Lisp-based languages like Scheme allow the programmer/user to customize the language as they desire through features like macros3, since in Lisps, code is data that can be manipulated just as easily as any other).
If you're not sure what "purely functional package management" means, it means that, among other things, effectively all changes to packages and configuration of the system are:
- Declarative - Instead of specifying what to do, you specify what you want. The system figures out and does what needs to be done to "make it so".
- Reproducible - System configuration is effortless to deploy across multiple machines or virtual machines. Changes to the system can easily be rolled back to previous states. Thanks to Guix's integration with Git and with the Software Heritage Foundation, a configuration you made years ago can continue to be deployed or rolled back to indefinitely, even if the software used in that configuration is no longer available from its primary source.
- Non-conflicting - Multiple versions of the same package, or conflicting packages, can be installed simultaneously without any problem.
- Unprivileged - A user can install packages without needing superuser privileges.
- Efficient - Unlike container systems such as Docker, conflicts are avoided without unnecessary duplication, thus reducing the space they take up on disk and in memory.
All of this also enables other cool features, like being able to spin up clean, isolated environments that contain only the packages you've specified.
As mentioned above, Guix is also a "meta distribution". In other words, it's not simply its own package manager4; importing packages from other package managers is a first-class concept in Guix, as is exporting a Guix package as a non-Guix one, such as a Docker image, a Debian package, an RPM package, an AppImage, etc.
The umbrella of Guix and adjacent projects includes other cool software as well:
- Guix System - The operating system built upon Guix.
- Guix Home - Functional and declarative user-level configuration management. What Guix does for system configuration, Guix Home does for user software configuration.
- Shepherd - Service manager and init system; a Guile-based alternative to systemd, SysVinit, etc.
- mcron - A Vixie cron-compatible periodic task scheduler written in pure Guile, allowing infinite flexibility in specifying when jobs should be run.
- GNU Hurd - A Unix-like operating system core, supported by Guix as an alternative to Linux. It has some interesting advantages.
Nyxt  lisp web software
(Aimed to be) the ultimate power user's browser, Nyxt is a fully programmable, customizable, "self-documenting", keyboard-centric, engine-agnostic web browser written in Common Lisp. It's effectively the Emacs of web browsers.
At the moment, my primary browser is Vivaldi, which is also a very powerful browser, but in the future I intend to switch over to Nyxt. Though Nyxt is already an impressive project, it's still relatively early in development, and still has some deficiencies. For example, it currently does not support standard Chrome extensions. Extensions can be written in Common Lisp, and plenty of features (including ad blocking) already exist in Nyxt or as Nyxt extensions, but if you want to use an existing Chrome extension, this is not yet possible (albeit in progress).
Since Nyxt is built in Common Lisp, the program expects that the user may change any and every part of it at runtime, even from the very low-level core. Malleability and customization are woven into the design and ethos of the language.
Nyxt paints the picture of a future where the web could be simpler, more consistent, and easier to understand. With the advancement of WebAssembly, maybe someday having to learn three different languages (HTML, CSS, JavaScript) just to access its full potential will no longer be necessary. Maybe someday, the language of the web can be a lisp, as it was always meant to be.
PipeWire  linux audio video software
PipeWire is the next generation audio (and video!) server for Linux… Well, actually, it's the current generation now 5. It replaces JACK and PulseAudio, supporting applications of both simultaneously and transparently.
PipeWire is cool because it allows audio input and output to be routed between applications and devices arbitrarily. By default, applications get input from your microphone and send output to your speakers, but you can redirect them to other programs as desired, to apply filters or processing, record or analyze them, etc. The same is true for video and MIDI as well.
Early versions had some minor bugs, but recent versions of PipeWire are now extremely stable and reliable, even for "pro audio" use cases. Finally, jokes about Linux audio can die6.
Mahogany  linux lisp software wayland
A Wayland7 compositor written primarily in Common Lisp. Like other Common Lisp-based software, this means it's a fully dynamic environment where all functionality can be altered at runtime, only ever having to restart if the non-CL core has to be changed, as well as all the other benefits that are standard to Common Lisp (and lisps in general). Refer back to the Nyxt heading for more elaboration on that.
Currently, my window manager of choice is the X11-based StumpWM. Mahogany looks to be shaping up to be an excellent successor to StumpWM that will do away with the cruft it has accumulated over time, much like Wayland itself is doing for X11.
River  linux software wayland
A Wayland compositor that moves window management to a separate process, allowing Wayland window managers to be built more easily. Window managers can focus on window management, keyboard shortcuts, etc, while the compositor focuses on compositing and other lower level functionality. This means that we get one more of the benefits of X11 back (separate display manager/window manager), while also retaining the benefits of Wayland (simpler protocol, better performance, enhanced security, no screen tearing, and modern graphical features like high DPI, per-screen DPI, fractional scaling, etc).
McCLIM  programming lisp gui software
A free implementation of the Common Lisp Interface Manager user interface programming system. CLIM is to user interfaces what Common Lisp is to programming languages: a powerful, high level, object-oriented, and extensible system standardized to a specification.
CLIM is not just a way to get graphics on screen; it's a way to organize user interactions, a way to make programs that "understand" themselves: their functionality and the data they're operating on.
Like Emacs, every input you can provide a CLIM application (mouse clicks and drags, keypresses, touch, etc) is mapped to the same underlying "command" abstraction. However, CLIM goes even further with a variety of abstractions that build upon each other from low-level to high-level, allowing the developer the same flexibility as Common Lisp itself: you can start from a sensible middle ground, but go upor down the ladder of abstraction as needed.
CLIM allows the input mapping itself to be reconfigured if desired, meaning more complex inputs can be understood by the system in an intelligent way. For example, a drag action doesn't simply have to be "drag mouse button 1"; it can be "drag object A onto object B with mouse button 1". You tell the system what the input is, rather than explaining to it how to differentiate different intents from the "same" type of input.
Similarly, all output from the program is done through a single abstraction: the "sheet". A sheet is "an ideal form"; a region with infinite resolution and (potentially) infinite size upon which graphics and objects can be drawn. All widgets ("gadgets" in CLIM parlance) are sheets at their core. Sheets can contain other sheets in a hierarchy, allowing full user interfaces to be built. Just like interactors, sheets can contain live objects; the system remembers what an object is, its value, and any objects it itself contains, and you choose how an object is displayed ("presented")–even defining multiple types of presentations for a single object, depending on its context. For example, an object could have a textual representation, a more compact "iconified" representation, or a full representation for when you want to see it and its contents in complete detail.
One particularly interesting "gadget" in CLIM is the "interactor". An interactor is effectively a graphical REPL that, being a sheet itself, understands the objects and data that have been output to it, as well as the types of values that each input field accepts. When an input is expected, the user can click on an existing object to use it as the input for that field (only objects valid for that field can be clicked), or perform any other input that can be mapped to an acceptable value.
Since interactors and sheets are themselves abstract objects, they can be mapped to various output types: a CLIM program and its objects can be drawn to a terminal, a graphical window, or maybe something else entirely. CLIM is even agnostic to its graphical backend: while McCLIM has historically been developed against an X11 backend, an SDL backend is in the works.
Unfortunately, there are a few downsides of McCLIM (and CLIM itself):
- It's pretty different from most ways of designing a user interface, and as a result it's not the easiest system to understand. Though you can ignore the more advanced features and just use it just to draw graphics to the screen, this misses a lot of the point of CLIM and leaves many of its advantages on the table.
- They are very old projects. McCLIM has bit-rotted over time, and as of my most recent attempts at programming with it, I found a few bugs. Fortunately, it's still under active development, so I expect this to continue improving over time, though not as quickly as I wish it was. I'm supporting McCLIM's development on Patreon, though. :)
- As a consequence of the previous point, right now McCLIM's only officially-supported backend is the X11 backend. That means McCLIM programs can only be run graphically on systems running an X11 server. X11 is most popular on Unix-based OSes, but macOS and Windows both require you to install a third party server. Even on Linux, X11 is slowly being phased out in favor of Wayland (though X11 programs can still run under Wayland via the XWayland server). McCLIM does have an SDL backend in the works, which will solve this problem, but my understanding is that this backend is neither fully implemented nor recommended.
Factor  programming
When learning Factor, I kept getting the feeling that its designers had read the idea of the perfect programming language directly from my thoughts. It's a natively-compiled, interactive, concatenative stack-based language, with a modern, elegant, yet powerful design. It feels very Lispy with its focus on interactive development, its built-in graphical listener/REPL, CLOS-like object system, CLIM-like GUI toolkit, and more. It's incredibly fun and has been a joy to use, even as I am still wrapping my head around concatenative programming.
I feel like the easiest way to think about it (if you're familiar with other cool languages) is as a mixture of the best parts of Forth, Common Lisp, and Smalltalk.
Like Forth, Factor is a concatenative, stack-based programming language. At its core, it's a simple language: it reads left to right, and every function operates on a stack of the results of the previous functions. Because of this, not only are temporary variables never required, variables in general aren't required. Of course, you can still define functions using variables, if necessary (or even if simply desired).
Like Common Lisp, Factor is a highly dynamic, interactive language. Instead of a program being built with the typical edit-compile-run cycle–restarting your program after every change–you instead start Factor, and then grow your program organically. You can easily see and inspect its state at any time. And when there is an unhandled exception/error, instead of crashing, the language allows you to interactively choose how you'd like to handle it, continuing from the exact point the error occurred. You can even edit your functions at this point (or any point), in order to fix the error, and then continue. You never have to worry about re-creating the potentially-complex state that resulted in an error, because the program only terminates when you terminate it.
In addition, Factor is homoiconic, supports macros (MACRO:) and reader macros (SYNTAX:), and has a CLOS-like object system (i.e. with a meta-object protocol). In fact, even as much as I like Common Lisp, Factor surpasses it in many ways: it removes much of the weird, ugly, and/or crufty parts of Lisp, while retaining most of its good parts. Its compiler surpasses the CL compilers I've used in some ways; for example, when recompiling an inlined function, it will automatically recompile all functions that utilize the inlined function. Factor even has a CLIM-like GUI toolkit that retains many of CLIM's most interesting features, but designed in a more simple and easy-to-understand way. It even has a SLIME-like Emacs mode called FUEL.
Factor is also interactive in the Smalltalk sense: it is (optionally) its own development environment, based around a graphical "listener" where objects can be printed either as their code representation, or their fully-interactive visual representation. When designing a graphical user interface, you can print a widget to the listener and interact with it exactly as you would inside your program. The hyperlinked, interactive documentation for all loaded libraries are viewable within the graphical help browser, objects can be examined in the graphical inspector, and errors are handled with the built-in debugger.
Factor also has shares some nice properties with other languages as well: much like Python, it's "batteries-included", shipping with a large standard library, typically (but admittedly not always) well-documented.
A smaller aspect I like about Factor is that it has really nice naming conventions for its functions and functionality. For example, all common stack shuffling functions have easy-to-write names like swap, dup, drop, 2drop, rot. Predicates and conversion functions have nice Scheme-like names, i.e. number? to check if something is a number, string>number to convert a string to a number, >float to convert anything to a floating point number (as long as it makes sense to do so), and append! to mutatingly-append to a sequence.
Factor has a small but dedicated community that are slowly building the language. Though (for now) Common Lisp is still my "main" language, I will continue to come back to Factor (I'm working on a SuperCollider interface library for it, for example) and I hope that more people will discover it and how cool it is!
Matrix  networking communication messaging software
An open, federated/decentralized communication protocol for synchronizing histories between participating servers. Most commonly used and known for instant messaging, but can also be used for real time synchronization and conflict resolution of arbitrary data.
Matrix is interesting for many reasons:
- open standard - Development of the standard is open; you can see and participate in its development, and anyone can implement their own client, server, bot, bridge, etc.
- open source - Most (all?) of the popular clients are open source.
- bridges - Designed to support server-side bridges between other protocols such as IRC, XMPP, Discord, Telegram, etc.
- encrypted - Supports end to end encryption (enabled by default for direct messages).
- mediums - It's not just text; Matrix supports audio and video chats too.
- federated - Like email, you choose your provider, and then you can communicate with anyone else on Matrix (or on the bridged networks).
- synchronizes history - Matrix doesn't just synchronize messages; it's designed to synchronize full chat history between the servers of users participating in each room.
- built on standards - Standard Matrix is just HTTPS and JSON, which makes clients easier to implement.
- adoption - Though it will have to fight the network effect, there is already significant adoption:
- Many open source projects (KDE, FOSDEM, Mozilla, …).
- Various government organizations across Europe (France, Germany, …).
- Other instant messengers are even switching over to it (Rocket.Chat, Gitter, Mattermost, …).
The most well-known client is Element, but there's also a cool and quite advanced Emacs client called Ement.el, among many others.
IPFS  networking software
The InterPlanetary File System is a peer-to-peer content-addressable filesystem. It's a bit like BitTorrent in that each piece of data in the system is identified by a hash computed from its contents, thus allowing the client downloading data to verify the integrity of the data. It's effectively impossible to man-in-the-middle because the "address" of the data is the hash itself.
Also similar to BitTorrent–and in contrast to location-addressed systems like HTTP–is that data that is popular becomes more available rather than less.
Other projects under the IPFS umbrella include:
IPNS - InterPlanetary Name System
Like DNS, but for IPFS. It is a system mapping mutable names to immutable data. Effectively, this allows for "updating" the data at a particular "name", even as the data itself remains immutable and thus retains the benefits of immutability. "IPNS names can be thought of as links that can be updated over time, while retaining the verifiability of content addressing."
IPLD - InterPlanetary Linked Data
IPFS's data model. It allows representation of Git structures, Ethereum blocks, and filesystems all within the same unified namespace.
libp2p
IPFS's networking layer that handles the complexity of connecting peers through NATs, firewalls, etc, over various transport protocols (TCP, QUIC, WebSocket, WebRTC, WebTransport). libp2p supports roaming, so a connection is not dropped when, for example, you move from one WiFi network to another. Additionally, all connections are encrypted.
Multiformats
A collection of protocols for self-describing values, thus making them futureproof. Multiformat protocols self-describe with in-band information--within the data, rather than contextual to the data–meaning that the ability to understand a piece of information cannot be separated from the information itself.
Multiformats itself also has projects under its own umbrella, such as:
Multihash
Futureproof self-describing hashes. A multihash specifies not just the hash, but the hash algorithm. This means that IPFS is not stuck to a particular algorithm or set of algorithms; any content on the network can be identified by any hash algorithm in the multicodec table, which itself can be added to. Thus, if an algorithm is ever cryptographically broken, "upgrading" to a better one is simply a matter of recomputing the data's hash with the new algorithm.
Multiaddr
Self-describing network addresses. A multiaddr address specifies not just the address (i.e. an IPv4 address or IPv6 address), but the protocol (i.e. not simply "HTTP", but specifically whether it is HTTP, HTTPS, QUIC, onion, etc). A multiaddr tells you the type of the address, the address itself, the port, and the protocol. This differs from a regular URL (i.e. https://modula-t.org), which only tells you the protocol and the address. Multiaddr uses the same multicodec table as multihash does.
LoRa  networking communication hardware
Standing for "Long Range", LoRa is a radio technology along the lines of WiFi and cellular, but with much lower power requirements and much higher range (3 miles within busy areas like cities, and up to 10 miles without obstacles). LoRa is particularly interesting because it's the backbone of modern mesh networking–if node A is within range of node B but not node C, but node B is within range of C, A can communicate with C by passing a message through node B.
LoRa is the physical layer behind technologies like Meshtastic and MeshCore, and many are already running nodes on these networks. However, both of these are LoRa-only. Better would be something transport-agnostic, like…
Reticulum  networking communication software
A mesh network allowing communication via a smart, transport-agnostic communication stack. Effectively, this is the internet 2.0, as it can be thought of as a true successor to TCP/IP, covering the application, presentation, session, transport, and network layers of the OSI model. Of course, the application layer can be securely extended with user-defined applications as well.
Encryption is a requirement of the protocol, thus it's effectively impossible to do man-in-the-middle attacks or listen in on communication between two nodes. Even if the encryption key for communication was somehow cracked, it would only work for a single packet, rendering surveillance hopeless. And despite all this, reticulum is extremely efficient, supporting high-latency, low-bandwidth links.
With the direction the internet is heading–where (for example) everything is increasingly being shoved through port 443 (even DNS is heading that way), it increasingly feels like a good time for a reboot–done right: modernized with the knowledge we've gained since its creation. I'm far from an expert, but Reticulum seems like a very interesting candidate thanks to its flexibility (i.e. transport-agnostic), security (mandatory encryption), and lack of the accumulated cruft of our current network stack (notably, "ports" and "addresses" do not exist in Reticulum; instead replacing both with the singular concept of a "destination").
While Reticulum is similar to projects like Meshtastic or MeshCore in that it's also mesh-based, unlike them, LoRa is not required, though it is supported–along with in theory any transport, such as WiFi HaLow, packet radio, etc.
Resonite  gaming software vr
"Realtime collaborative social VR sandbox platform" (as per Frooxius's Bluesky bio).
Resonite can be thought of as somewhat similar to platforms like VRChat and Second Life: it's an online virtual world platform allowing users to meet, chat, play games, and more in shared virtual 3D spaces. However, unlike Second Life, it's a much more modern and advanced virtual world platform built for the virtual reality era. You will not have difficulty finding its dedicated and enthusiastic userbase.
Further, unlike VRChat, Resonite is designed with the full potential of virtual reality in mind. If VRChat is for consumption, Resonite is for creation: you can design and program your own custom environments, objects, avatars, etc, all without ever having to leave Resonite, take your headset off, or even put down your controllers.
I definitely recommend the overview videos linked above, especially the first one. Note how users have built entire mechnical engines in-game that are not simply animations–they are the physical laws programmed in-game, and the world is solving for them and syncing the laws and their results to all users of the world. The same is true for the video feedback
Compared to VRChat, Resonite, despite not being the one with "VR" in its name, feels much more like a platform made by people who truly believe in VR–not just as a medium, but as an artform onto itself. own possibility space, . Virtual Reality can sometimes feel like a "solution in search of a problem"
According to Resonite's creator and main developer, he had the opportunity to sell off Resonite, but didn't because he didn't want it enshittified. To me, this speaks positively about Resonite in a way that its code and functionality can't.
Steam Frame  gaming hardware vr
The Steam Frame is Valve's soon(?)-to-be-released virtual reality headset - effectively the sequel to the (still much-loved among VR enthusiasts) Valve Index.
There are a few things that make the Frame cool to me:
- Linux-based - Instead of Android (🤢) or an even-more-proprietary OS, the Steam Frame's OS is a real Linux distro.
- Open - Not locked down at all–there is nothing stopping you from installing any software or OS you want, or modifying the hardware as desired. Considering how much community support the Index (and Steam Deck) received, I anticipate the Frame will likely have even more, and there will be plenty of cool software to enhance your VR experience.
- Foveated streaming - Since the Frame has eye tracking,
- Foveated rendering - Not just streaming, but full foveated rendering can be enabled in any OpenXR game, to save even more resources and processing power. Video example of this in "Climbey".
- Works both standalone and for PCVR
- Not made by Facebook!
MiSTerFPGA  gaming hardware fpga emulation
The ultimate multi-system emulation hardware. MiSTerFPGA is an open source FPGA-based game console, arcade board, and computer emulation platform. Because it's FPGA-based, emulation can be extremely accurate and extremely low latency (FPGA emulation is often described as "hardware-based emulation" to contrast it to "software-based emulation" that runs as a program on a standard operating system). The FPGA board can be reconfigured while the system is running, meaning you can play (effectively) any game or software that there is a MiSTer core for.
And there are a lot; an incomplete list of supported game systems includes:
- Atari 2600
- NES
- Master System
- Vectrex
- PC Engine/TurboGrafx-16
- Mega Drive/Genesis (& CD & 32X)
- Game Boy (& Color)
- Neo Geo
- Game Gear
- Super Nintendo
- Wonderswan
- CD-i
- 3DO
- Jaguar
- PlayStation
- Saturn
- Nintendo 64
- Pokémon Mini
- Game Boy Advance
While an incomplete list of supported computer systems includes:
- Apple I & II
- Commodore 64
- Atari 8-bit computers
- Atari ST
- Amiga
- X68000
…And this doesn't even include the arcade boards there are MiSTer cores for. You can see a full list on their Wiki.
Despite being a solution based on dedicated hardware and FPGA, MiSTerFPGA is by no means lacking features. One of the more nifty (in my opinion) is that you can enable an SSH server, so that you can manage your collection of ROMs, run updates, etc, without having to plug a keyboard or USB drive into it.
Mecha Comet  hardware
A modular, handheld, pocketable Linux computer.
Modular both in its software and hardware: software in that, though it has its own custom open source software stack, the OS and software can be replaced as the user desires.
And hardware in that both its internals and externals are designed to be as user-replaceable as possible. In addition to its AMOLED touchscreen, it supports swappable input faceplates, such as a physical keyboard (RGB-backlit, QMK-compatible, with HD trackpad) or a "gaming layout" (with 2 D-pads, built-in trackpad, and 7 face buttons).
Likewise, it's handheld and pocketable: the device is 155 x 73 x 14 mm in size, and weighs 225g.
In addition to the aforementioned, its hardware includes:
- 4- or 6-core ARM CPU
- 2, 4, or 8 GB RAM
- 64 or 128 GB eMMC internal storage
- 802.11ac WiFi, Bluetooth 5.4, SIM card support
- 3.92in AMOLED capacitive touchscreen display
- PCIe 3.0 port
- 8 MP camera
- 2 built-in mics
- HD speaker
- 4100mAh battery
- HDMI port
- 2x USB-C ports
- 9-axis motion sensor
And more…?
More things for this list, which I will add full sections for in the future.
The Freedom of Form Foundation  biotech
"Biotech for self-expression". A non-profit focused on the development of technologies that allow one to become their "true self" physically. If you want to become your sona (fur- or otherwise), you will find them interesting, and should support them (financially if possible)!
WiFi HaLow  networking hardware
Lem  software editor
A modern Emacs-like editor written entirely in Common Lisp!
Hyphanet  networking software
Formerly Freenet(?)
Nym  networking software
"Nym" is basically the next evolution of the concept of "distributed VPNs" like Tor. Nym provides more anonymity because it:
- Mixes "noise" into the signal to make it harder for eavesdroppers to parse/understand traffic.
- Splits the packets up across multiple different routes, rather than one route that is static throughout the connection (as is the case with Tor).
- Removes all timing and size characteristics from the packets, so that it's not possible to trace or correlate them based on such metadata.
Photonic Computing  hardware
Silent cooling/airflow  hardware
GPUs/GPU programming tech?  software
Semantic Wikis  software
Past technology
Maybe someday I will make a full page for old/obsolete technology that I think is cool. At the very least, I intend to finish a page about what made Cybiko so cool. For now, I'll just list some of my favorite "past technology" here.
Lisp Machines
Cybiko
Nintendo 3DS
Sega Saturn
Footnotes:
However, it's possible to run Guix on non-standard Linux operating systems (such as Android), and Guix System supports the non-Linux GNU HURD kernel.
Specifically, Guile Scheme, which is an implementation of Scheme, which is a member of the Lisp family of languages.
In fact, Guix itself ships with syntax sugar of its own called G-Expressions which assist in making package definitions shorter and easier to read and write.
Unless you use Debian or whatever, I guess.
…But will they, though?
Wayland is the modern graphical subsystem for Linux which replaces the ancient and crufty X11. The transition to it is still in progress, and unfortunately due to "developer politics" has gone slower than many, myself included, would like. But already, Wayland has come a long way, and is usable for most non-niche usecases.