2023

2023 has been a very busy year for me, both in life and in open source development. This year, I’ve started around 25 personal open source projects on GitHub (constituting the majority of my currently public projects!), joined a few larger open source projects, including Catppuccin and Elk, learned a wide array of new technologies such as Rust, and also revamped my personal privacy and security practices.

New Projects #

Compared to last year, I worked on much more of my own open source projects this year, which did place a pretty heavy maintenance burden with outdated dependencies and whatnot. Here are some of the projects I am most proud of:

• Mastoroute (January), a small web service to automatically redirect Mastodon users for share links to their instances, saved in cookies when they first configure the service. I built this for usage on this website, and you can still see it in the sharing footer!
• Modernflux (March), a custom stylesheet for Miniflux. Initially, this was just a Catppuccin palette applied with Miniflux’s custom properties-defined colors, but I prefer modern-looking UIs over Miniflux’s built-in look (which is… antique), so I gradually added more styles until it had a completely different, modern look. This was also my first major project that used SCSS (since I use Tailwind CSS most of the time).
• Daenerys (March), a web app built with SvelteKit that checks for common DNS verification records and deduces which services that the domain utilizes. I built this when looking around for good email providers (I stayed with the Tuta open source sponsorship plan from last year).
• gql (May), a tiny GraphQL querying library for JavaScript/TypeScript that I often use for my own projects to have a convenient API wrapper while avoiding the bloat of large libraries like Apollo.
• Vendflare (May), an alternative backend for Vencord built on Cloudflare Workers that supports multiple storage interfaces and has quite good test coverage with Vitest.
• What the DMARC (June), another web app built with SvelteKit that explains DMARC and SPF records, since I found them to be rather confusing when I was working with them myself.
• Tenable (July), an alternative analytics script for Plausible Analytics that came with an API proxy in order to work around blockers. It also uses more modern web APIs and includes support for bfcache, which I also PR’ed to upstream but received no reply for.

Rust #

I had come into touch with Rust for a few times before over the past few years, but I mostly didn’t bother to deal with it as the syntax looked difficult and arcane, and I wasn’t that interested in building things that were usually made with Rust. However, building some server-oriented services and CLIs led me to want to use Rust, since I wished to build standalone binaries and I encountered a variety of problems working with Go that I heard weren’t problems at all in Rust!

So, I spent about a day in July rewriting one of my Go projects, a Firefox userchrome manager called nyoom, in Rust. Of course, before that, I had a good thorough read of the Rust Book, which taught me about all the intricate features of Rust like the borrow checker. It inevitably appeared somewhat foreign, but through doing projects, I gradually got used to all the features and syntax specialties.

Here are some of the language features I found most useful in Rust:

• The built-in enums Result and Option, providing a unified and consistent API for errors and empty values and a good amount of functions to operate on them (compared to a certain language that has two empty values that don’t even behave like values all the time!);
• Traits, a great way to implement similar behaviors on different types;
• Macros, an extremely powerful and dynamic language feature that can help extend the language with attributes, modify code tokens, and automatically define implementations on structs and enums;
• Tokio, a reliable asynchronous runtime that has great APIs and simple multi-threaded support;
• serde’s unified ecosystem that supports a wide variety of formats and also supports deriving all the serialization/deserialization functionality from a struct;
• Clippy, a lot of lints to improve Rust code efficiency and recommending better code styles, often introducing me to new Rust language features I had no idea existed but cleaned up my code greatly;
• Iterators and the dozens of useful methods that it implements, allowing for simple, chained, and effective modification of collections of items.

But overall, what attracted me most was the ownership system and borrow checker. Knowing very clearly and specifying very explicitly whether I was passing around or consuming values, or references to values, or mutable values, or references to mutable values, helps greatly in reducing unintended behavior. Which closure is using what and which value owns what other values becomes crystal clear under the Rust system. What’s more, Rust (and Tokio) provide a good amount of synchronization primitives that help things work properly even across complex situations like multi-threading and concurrency.

Sometimes, pacifying the borrow checker can be quite painful, with cryptic compiler errors and whole blocks of code getting red squiggles all at once. But Rust is one of those languages where you can really expect things to probably work once they compile, which definitely can’t be said for many other languages.

After finishing the rewrite of nyoom, I went on to create several other Rust projects: nrr (November), a minimal and blazing fast Node.js script runner; am (September), a beautiful and feature-packed Apple Music CLI; choirpack (September), a collection of utilities for working with Node.js’s Corepack; and Valfisk (October), the next-generation Discord bot superseding my old bot written in discord.js.

Learning Rust was, admittedly, a roller coaster. Usually, I like to dive head first into projects and learn through the experience, but, as I found several times before, this model does not work for Rust. Rust’s beauty and great features can be very hard to comprehend if you do not first have a conceptual overview of them, and that was why I ended up abandoning Rust in my previous attempts to learn it. It’s difficult to change your model of learning things, but with enough patience and flexibility, I managed to find the problem in my learning process so as to better acquire the skills that I was interested in.

Nix #

Another technology that I had a similar situation with was Nix. (As it happens, Rust and Nix work together remarkably well.) I had been coming into contact with Nix for a while, and this year I resolved to learn it for good, and manage my system with it. The mindset that it is founded upon is a unique one, very different from what you usually expect from a package manager, and that is also why I spent so much time warming up to it.

But similar to how my learning process with Rust went, I took the time to study it, including reading the 2004 paper that first proposed the principles on which Nix are founded, and came to appreciate and love Nix for its reproducibility, flexibility, and convenience. Nowadays, I manage my macOS system in Nix with nix-darwin, and it is working splendidly for me: a breath of fresh air from the mess of packages and configurations scattered throughout my system.

I wrote a whole blog post on this journey a few days ago, so go check it out!

Self-hosting #

This year, I also decided to buy a server for myself so that I could host lots of services that I used for myself instead of using (and often paying a lot for) other people’s instances or equivalent services. Initially, I used an AWS EC2 instance because that was probably the most production-ready provider out there, but later on I switched to Contabo, a German cloud server provider that had wonderfully decent costs and freed me to do much more on my machine.

I initially set up this VPS in May; I’ve written about that extensively in a previous blog post. Since then, I have added a variety of services to the portfolio, including a personal-use Firefish (Fediverse) instance, a Forgejo instance, and various other long-running hosted services.

Although many nowadays may support serverless-only deployments and edge functions, I believe the traditional monolithic server still has its place in the web development world. They are reliable machines that can execute long running processes and are flexible enough to accommodate a wide range of activities, and although they might be complemented or even considered to be replaced by serverless and edge functionality, it is important to remember that in the end everything is coming from a server, whether it’s here, there, or everywhere.

Moddermore #

As my flagship product, Moddermore has seen a consistent year of updates in 2023. I redesigned the landing page to incorporate more information and make it more appealing for new comers as a SaaS product; I also added a vast variety of features, including analytics, mod version pinning, advanced Modrinth pack customization, Modrinth pack import, packwiz export support, integrated editing support, improved design, performance optimizations across the board, a public changelog…

The user and list count continues to grow on Moddermore as presumably more and more people spread the word by simply sharing the links to their Moddermore lists. This has been the growth model that I planned to rely on, since the links themselves spread visibility of the product and those who have a demand for the product would naturally gravitate to the service.

I plan on maintaining the product more actively in 2024 while balancing it with my coursework, since I want to accelerate feature development as competing products with similar niches start to develop. In addition, I still don’t have a clear monetization plan on how to proceed with product development while maintaining revenue, so I will have to work on that. Currently, donations are sporadic and quite unreliable, so I plan on adding something of a premium or pro plan that adds more features, but one thing I’ve resolved to do is definitely avoid removing old available features, since from my experience with Plausible’s pricing changes, I’ve personally found that making previously freely available features locked under a paid plan can be a real annoyance for users.

Website Updates #

This website is the front page of my online presence; as such, I spend a lot of time working on it to make sure that it maintains the high quality of work that I aim to produce. This year, I changed the layout of this website several times, ultimately ending up with a side-by-side layout like several iterations before and also adding the Inter font with aggressive optimization techniques and a few font variation settings toggled on to create a unique and interestingly look. I’ve also added more interesting layout features like the metadata sections and the new donation call-to-action, and improved the design of special pages like the uses page.

Open Source #

At the start of this year, I joined two organizations on GitHub: Catppuccin and Elk, the former as a port maintainer and the latter as a triage team member. Although I spent more time on my personal development and personal open source projects this year, I kept up the open source contributions. For Catppuccin, I currently maintain six Catppuccin userstyles, along with several other ports. For Elk, the project isn’t as active now as I hoped, but I still opened a lot of bug-reporting issues and, correspondingly, bug-fixing pull requests during the early days of its development.

I’ve also made a sizable amount of contributions to other open source software, making fixes and adding features to software that I regularly use and also helping out friends with my web development expertise. The GitHub contributions section of my projects is page is intended to be a way to showcase those contributions that aren’t so major or significant, but bit by bit make up my involvement in and giving to the open source community.

As a final note, thank you to all the friends and all the supporters who helped make this year meaningful and cool for me! Happy New Year!