• Arcade Stick Modding: Modding my 8BitDo arcade stick
• Rails Templates and Generators: Learning about Rails templates and generators
• Interesting Links: Cool things I found this week

Arcade Stick Modding

I decided to finally pull the trigger on modding my 8BitDo Arcade Stick and making it a leverless for playing Tetris the Grand Master 4 -Absolute Eye-. I was inspired to do this because I started playing on my keyboard again and instantly played so much better than on a joystick. I’ve also wanted to upgrade the buttons to proper Sanwa ones too.

I’ve ordered the parts off of AliExpress as I’ve had good results getting my other arcade controllers from there.

I’ve ordered the SITONG Mixbox-C and some nicely coloured Sanwa OSBF-30 buttons. I’ll be sure to post updates when they’re here and installed. I’m considering making it into YouTube video.

SITONG Mixbox-C

Sanwa OSBF-30

Rails Templates and Generators

I’ve just started looking into Rails Templates and am honestly fairly disappointed with how limited they are. I’m hoping I’m just not seeing something and won’t have to write a lot of code to make them do all the modifications I want.

I also plan to look into Rails Generators to really speed up my development for basic create/read/update/destroy things.

My rough plan for this is to convert my expense tracking app into a Rails app as I’m a bit annoyed by the poor performance of my Poros gem.

Interesting Links

Never Buy A .online Domain: Horrifying how much power google and centralised systems can have.

Element: setHTML() method: setHTML is exciting, no longer is HTML sanitization an extra dependency and is hopefully going to be in the JavaScript standard library.

Why is WebAssembly a second-class language on the web?: Making WASM a first class language is very exciting, it’d finally mean a real alternative to JavaScript

snakes.run: rendering 100M pixels a second over ssh: Performance improvements of snake over ssh and taught me some ANSI escape tricks I didn’t know.

3 years of Crystal Lang programming: The good, the bad, the ugly: Looking into Crystal ORMs I found this interesting breakdown of Crystal.

Your first PICOTRON cartridge in 10 minutes : A 10 minute intro to Picotron, a really cool little fantasy computer.

Enable CORS for Your Blog: Enable browsers to fetch your rss feed directly, I’ll hopefully get this done for my blogs soon.

Build your own Command Line with ANSI escape codes: A cool intro to what’s possible with ANSI escape codes and how to build a REPL with it.

An Interactive Intro to CRDTs: A fun intro into CRDTs with lots of interactive examples.

• Taylor Community: Working on the Taylor Community site continues anew
• Building a Programming Language: The bad thoughts win and I look into building a language
• Interesting Links: Cool things I found this week

Taylor Community

Now that I got warden working with Hanami I’ve decided to go back to my Rails implementation of the community site. While I’ve enjoyed Hanami I’m looking to have a high velocity with this so sticking with tooling I know is going to be better. I will absolutely revisit Hanami later as I liked a lot of the decisions they’ve made and found it a great experience.

Going back to an old codebase always means I get to do one of my favourite things, upgrading libraries! I’m not even kidding, I get a lot of pleasure out of bumping gems and doing Rails upgrades. So now it’s running on Rails 8.1.

I decided to take it a step further though and rewrite the entirety of the erb templates I was using into Phlex. I find using Phlex a much nicer experience than writing erb templates.

Building a Programming Language

I’ve gotten the itch to learn how to make a programming language. It’s mostly for the learning experience. I’m curious how all the parts come together to create a binary. I’m familiar with lexers and abstract syntax trees (AST) but I’m excited to learn how an AST turns into a language-independent intermediate representation and then into actual machine code for different platforms.

I’ve been looking at the createlang.rs website and trying to use it in conjunction with parslet to do this in Ruby. This is because ideally I’d like to design a language fairly inspired by Ruby.

I actually have part of a blog post written about my thoughts and complaints about current languages that I think could be interesting. I might try and focus on getting that finished while doing this project.

Interesting Links

Farewell, Rust: Another article about how low level languages aren’t ideal for writing web services.

High-level is the goal: The premise here is that high level languages have nicer tooling and if low level languages had better tooling more people would write efficient software. I dunno if I completely agree with the article, but it’s interesting.

Most Developers Don’t Build New Things: A nice reminder that most software development work is overwhelmingly maintenance and not greenfield projects.

How I made a shooter game in 64 KB: Wow, this was amazing. So many amazing tricks including “just writing a new language because it’s more effecient”.

mruby-examples: A repository for examples of how to use mruby - which is what Taylor uses for scripting.

How We Fixed YAML Comment Preservation in Ruby (And Why We Sponsored It): I had no idea this was possible.

The Death of the Software Craftsman: A great take on the current state of software development with regards to LLMs. I’m not sure I agree entirely with the three options at the end, but it’s interesting.

Roguecraft GB: The process of porting Rogecraft DX to the Gameboy Colour, a truly impressive feat of engineering.

• gitsigns: Switching git plugin for Neovim
• Hanami: Continuing my Hanami learning
• Jumpy Alien: Improved the game design
• Interesting Links: Cool things I found this week

gitsigns

I have been using vim-gitgutter for many years and it work great for what I wanted, displaying diff symbols on the side of my editor. After seeing a coworker bring up a git blame side pane and jump through the history of that file right in the editor I knew it was time to upgrade my git plugin for Neovim.

After hunting around for a while and ruling out more complicated plugins I came across gitsigns and almost ignored it because I thought it couldn’t do what I needed. Thankfully I actually installed it to test it out and saw that it can jump through history easily.

vim-gitgutter

gitsigns

This is honestly a pretty terrible comparison, but this is the only feature of vim-gitgutter that I used before switching. Now that I’m using gitsigns I can do some cool spelunking into my code’s history.

I did hit the error

Error running git-blame: fatal: could not open object name list: .git-blame-ignore-revs

with gitsigns though, if you use the ignoreRevsFile global configuration setting in git but that file doesn’t always exist in your repositories, it will error when you open Neovim. I found the fix was to tell git that the file is optional.

[blame]
  ignoreRevsFile = :(optional).git-blame-ignore-revs

Hanami

I’ve finally got warden integrated into my Hanami application. It was quite the learning experience and I plan to write a full blog post on it soon so I’ll keep this brief.

I mostly enjoyed the experience but it’s definitely very different from what I’m used to with Rails. I think the part I’m having the hardest time adjusting to is the database layer as I’m actually pretty fond of ActiveRecord.

You can see the full commit over on GitHub if you’re curious how it went.

It’s an adaption of this blog post with a little help from the Hanami discourse.

Jumpy Alien

I got Jumpy Alien updated for Taylor v0.4.1. This was mostly the change around Texture2D#draw no longer defaulting the origin to the centre of the image and instead puts it back at Vector2[0, 0] to make it work like nearly every other #draw function.

I did some gameplay improvements too.

• The pipes now spawn at random heights
• Player gravity tweaked
• Pipe movement speed tweaked
• Exit button now works

Interesting Links

You are being misled about renewable energy technology.: I was initially skeptical of this video but it helped enlighten me on something I was very naive about, battery recycling.

THREE.js-PathTracing-Renderer: Every single demo here is mind blowing to me, the fact this runs in a browser so smoothly is amazing.

The Handoff Test: Something I try to live my life by, making sure I’m not the sole keeper of any knowledge at work.

• Ditching Windows: The final steps to ditching Windows
• Expense Tracker: Finally wrapping up the main work for this project
• Taylor: Someone sent me an email
• Interesting Links: Cool things I found this week

Ditching Windows

I’ve been a Linux user for many years now. My distribution of choice is Fedora as I’ve basically had zero issues using it and keeping an install updated for many years. I do basically all of my computing with it.

With Windows 10 finally hitting End of Life and Windows 11 being full of ads, AI, and other garbage I’m finally making the effort to migrate the last remaining uses of Windows over to Linux. This means getting my games running. Thankfully Steam has trivialised this. The only game I’ve had issues with so far is Overwatch but I’m working through that.

Expense Tracker

This has finally hit a point I’m happy with it and can consider it “basically done”. I’ll use it for a couple of months and make any small tweaks I think I need to. I might also polish up the interface a bit more too. I’m too lazy at the moment to anonymise some data and take a screenshot, but rest assured it looks like a developer made it.

The final feature list is actually kind of impressive given it’s only had a few days development:

• Import CSV of transactions
• Create, read, update, destroy categories
• Create, read, update, destroy subcategories
• Create, read, update, destroy rules
• Auto-categorise transactions using rules
• Show reports broken down into categories
• Mobile responsive
• Track account balances from the imported transactions

Taylor

I received an email about Taylor! Someone noticed a bug on the playground and reported it. This small act by them made me feel like I’m actually making a difference with this project.

The thing that makes me chuckle about this bug report is that they’re focussing on the missing y call on the Vector2 but mention nothing about the clearly broken background drawing.

I’m very thankful for this report though, I have fixed both of these issues but I’m still not sure how to tackle keeping regressions like this from happening automatically.

Interesting Links

Disney Comic Strip Artist Kit: Came across this on Mastodon and thought it could apply to game design too.

I put a real-time 3D shader on the Game Boy Color: A very cool tech demo. (CW: minor AI usage)

Let’s compile Quake like it’s 1997!: Running through how to compile Quake using an approximation of the tech stack originally used.

SectorC: A C Compiler in 512 bytes: I mean, you just gotta read this one.

On Building Communities in Public: Why I Chose Discourse Over Discord: This gave me some great ideas for the Taylor community site I’m building.

Against the protection of stocking frames.: Look at AI through the lens of it already being a failed technology.

How I Cut My Google Search Dependence in Half: An extremely interesting new idea of using your browsing history as a search engine. The tool is very early days and buggy, but the idea is amazing.

Ubuntu Live CD was Based on Knoppix: A thread on Mastodon showing that the original Ubuntu Live CDs were built on top of Knoppix.

The open source design stack: A look at FOSS tooling for doing design work.

• Poros: Updated my gem after 7 years
• Expense Tracker: Smashing out a new project
• Kiwi.nvim: Smashing out a new project
• Taylor Monthly - January 2026: My first monthly Taylor post
• Interesting Links: Cool things I found this week

Poros

When I first wrote plain old Ruby object storage (poros) the YAML Ain’t Markup Language (YAML) parser in Ruby didn’t protect you against loading arbitrary classes. Now it stops you as that’s obviously a very dangerous default. I didn’t want to just allow everything - and I’m not sure it’s even possible - so I instead made it configurable.

Poros::Config.configure do |config|
  config[:permitted_classes] << Date
end

I considered making it a per-model attribute but didn’t want to spend too long on this as it’s mostly just a fun project that I needed to update for my expense tracker I’m building for myself.

This does mean I got to do a release after 7 years of inactivity! I was surprised that the gem “just worked” on Ruby 4.0 without modification. The only difference was the safe loading.

Expense Tracker

Over the weekend I started a new project to help track my expenses. It’s fairly simple and has a few goals.

1. Load my transactions from a comma separated values (CSV) files
2. Let me categorise transactions
3. Work on mobile
4. Break down my spending in an understandable way

I’ve built something like this in the past and built it on Vue.JS. This time I wanted to build it with as little JavaScript as possible. This was just a fun extra challenge for myself.

I decided to use Sinatra as I’m used to it and like it for small projects.

I got a large chunk of the project built-in 1.5 days by limiting my testing to only parts of the system I didn’t have high confidence in. So far this has meant only my importing class. This has allowed me to move very fast and all the bugs I’ve had have been minor.

I’m considering releasing it for free if I’m happy once I consider it “done”.

Kiwi.nvim

My coworker was showing me their Org Mode setup and it make me want to get off my arse and get my wiki situation sorted again. I used to use VimWiki but wanted something lighter and more geared towards Markdown. I found kiwi.nvim in my search for a solution. I’m liking it so far. It checks most of my boxes. The only two things I am missing are:

1. Lists continuing on newline
2. Tables formatting nicely

I solved the issue for tables with the help of this blog and I turned it into this keybind.

vim.keymap.set(
  'v', '<S-t>',
  ":!column -t -s '|' -o '|'<CR>",
  { desc = 'Format a markdown table' }
)

It’s not perfect but it does the trick. Also, don’t be surprised if I’ve forked kiwi.nvim or even rewritten it by next week. It’s only a couple hundred lines and I’m not chuffed with the code quality.

Taylor Monthly - January 2026

I wrote up and published my first Taylor Monthly and I’m fairly happy with it. I spent all of Saturday morning writing it up. Thankfully I had done a lot the prep work because most of it is taken from my Weekly Brain Dumps and tweaked slightly to read better for there.

The biggest thing for me though was show how much I had actually done on Taylor during the month. It’s surprising that I got this much done on top of a full time job and - honestly - way too many hobbies. It’s no surprise that this past week I’ve been taking it a bit slower and trying to detach from my computer.

In fact, these Weekly Brain Dumps have actually highlighted to me that I do a lot of programming out of work. I would like to start introducing more analog hobbies into my life again. I used to have a lot of them as a kid and there are some I’d like to give more time too. Maybe I’ll make an effort to document them here too? I guess this doesn’t have to be a technical blog, I’ve just kind of imposed that limit on myself subconsciously.

Interesting Links

Mecha Comet: This might be the most perfectly designed handheld Linux computer, we’ll see if it lives up to the hype.

NES.css: This was nearly the CSS framework I used for my website.

Kemal Website: This is the Sinatra of Crystal and I have been meaning to build something with it.

Lichendust Blog: An interesting blog I found that also does an “interesting links” section!

CapRover Deploying with the Wrong Platform: How I solved my CapRover issue with the help of the developer.

gem.coop update #4: cooldowns beta: An awesome idea to hold back updates for 2 days. This has been shown to minimise most compromised packages reaching you nearly entirely. I’ll be switching my projects to this.

The cost of running OpenBenches.org: This does a great job of showing just what it takes to run a site like this.

I had two versions of the ruby:4.0 Docker image, one for linux/amd64 and one for linux/arm64/v8. For reasons we still don’t know, CapRover was using the linux/arm64/v8 version for deployment.

By running docker image rm ruby:4.0 and redeploying my application it was built using the image form the linux/amd64 platform.

The Problem

Recently when I deployed my web applications to CapRover they were using the images for the linux/arm64/v8 platform instead of the linux/amd64 that my server actually is¹. Whilst this technically worked it had massive performance penalties because I was running everything through QEMU as that’s how I have Docker multi-platform setup.

Strangely when running docker build . in the project root on the server used the correct linux/amd64 platform.

I had absolutely no idea why this was happening. I dove into the CapRover code and it didn’t specify the platform anywhere. I got so lost with this I actually raised an issue on their GitHub

The Work Around

githubsaturn was very patient and incredibly helpful in working around this issue. By running docker image rm ruby:4.0 and redeploying an effected application using that image it deployed correctly using the linux/amd64 platform. As I have a fair few of these non-linux/amd64 images on my server due to testing [neospec] and [LocalCI] I have written a script to clean them up.

1. Download the script
2. Run chmod +x docker-clean-other-platforms to make it executable
3. Run ./docker-clean-other-platforms.

Dangling Threads

I don’t consider this “case closed” as I want images with other platforms on my system for testing my Ruby gems.

My big suspicion is that it has something to do with running Docker inside of Docker. I suspect that because installing CapRover is done with the command docker run -p 80:80 -p 443:443 -p 3000:3000 -e ACCEPTED_TERMS=true -v /var/run/docker.sock:/var/run/docker.sock -v /captain:/captain caprover/caprover. Which means everything CapRover doe does with Docker is done through that container.

If I ever figure out why this is actually happening and how to permanently fix it I’ll update this blog post, but for now I think I’ll leave it there.

• Projects Page: A new page showcasing my projects
• The Write Clean: Continuing work on profiles
• Taylor: Released Taylor v0.4.1
• Taylor Website: Migrated to simple.css
• Taylor Examples: Finished the gameplay loop
• Interesting Links: Cool things I found this week

Projects Page

I’ve added a projects page to this blog to show the things I’ve built that I’m proud of. There’s at least two more projects I’d like to add there but they are not in a running state due to their age.

I also want to put some screenshots or something to spice the page up. Right now it’s incredibly plain and doesn’t do a great job at selling how cool these projects are. You know what they say though!

Just make it exist first… You can make it good later!

• Them

The Write Clean

I continued work on profiles and reacquainted myself with the codebase. I’m actually a lot less annoyed by it having looked it at again. I’d built it up in my head that HTMX had made all my ERB templates awkward but it really hasn’t.

Taylor

Texture2D#draw no longer sets the origin to the centre of the destination and is back to Vector2[0, 0]. This was a change I made when I was doing the big redesign but have come to realise it’s a bit weird and unexpected for users. So I have reverted this change.

Something that took me longer than expected was updating to clang-format 21 because I was getting annoyed by the differences between the installed clang-format on Fedora and Debian. I also took this as a chance to tweak the settings slightly. Specifically these two changes.

• ColumnLimit from 80 to 100
• BreakAfterReturnType from TopLevel to Automatic

I also went and released Taylor v0.4.1! I’m thinking I’m going to try and do frequent releases rather than waiting for some big change to happen. This will keep the deployment pipeline working and I feel help raise some awareness for the project. It will also help make it look like it’s not dead.

Taylor Website

I’ve completed all my cascading style sheets (CSS) changes for my websites now. This means this blog, the Taylor website, and the Taylor Playground are now all based on simple.css. This also means they all have both light and dark modes that change based on your preferences.

I have redesigned the Taylor documentation page to have the more useful content towards the top of the page. It now also generates the library links from the gembox file, so it stays up to date with each new release.

Old Documentation Page

New Documentation Page

Taylor Examples

Jumpy Alien now has a complete gameplay loop! It’s incredibly bare bones and the game design is awful but it’s still a big milestone. I can now spend time refining the project and making it feel nicer.

Interesting Links

Why there’s no European Google?: A look into the differences between European success and American success.

Reviving Life is Strange: Before the Storm on Modern Linux with a glibc Shim: This shows us how brittle binaries on Linux can be thanks to glibc but does show an interesting trick to get this specific game to work.

Ruby::Box: Rethinking Code Reloading with Isolated Namespaces: Looking into the new Ruby::Box feature and how it can be used to do hot reloading safely and how it’s not quite there yet.

You might not need a sync server for real-time collaboration: How to write real time JavaScript projects without needing a server.

• Taylor: Merged the LocalCI pull request!
• Taylor Examples: Did some thinking
• Interesting Links: Cool things I found this week

Taylor

I got my LocalCI pull request merged!

Everything went really smoothly except for running the test suite through wine in rake in Docker. For some reason it ran perfectly fine if I connected to the Docker container and ran it myself, or if I ran it through a simple rake file. But when I ran it through LocalCI with everything setup it was resulting in invalid pointer. Thankfully updating to the latest stable wine resolved this and now it works great!

I did end up taking the approach of running everything in a single pipeline step as this allowed me to leverage the resources of my single test machine easier thanks to rake using multiple cores by default. The only downside is I run my Docker builds sequentially as my server doesn’t handle building them all at once well.

Taylor Examples

I haven’t written any code but I have done quite a lot of thinking about Jumpy Alien. I’m currently unhappy with my approach to Test Driven Development (TDD) and think I need to dial it back as game development is very different to web development. I feel there’s a sensible amount of TDD that can be done but it’ll be different from how I’m used to doing it.

I’m also unhappy with the way I’ve architected the components of this project. I’m thinking of simplifying the models and taking a more data oriented approach. I’m hoping to have an interesting section here next week saying what I’ve changed and how well it has worked.

Interesting Links

Infinite Coffee Glitch: This is a great reminder for back end validation. Never trust clients!

Strudel: A live music coding platform that’s free and open source

This game is a single 13 KiB file that runs on Windows, Linux and in the Browser.: An interesting approach to a polyglot executable. Sadly it’s three separately made implementations of the one application, but still cool.

Win32 Is The Only Stable ABI on Linux: I think about this article frequently.

mruby on Zilog Z80: Yuji is the person who introduced me to mruby, they’re currently writing an implementation that runs on a Z80!

Infinite Mac: I was watching this Action Retro video and he used this site to create a bootable system for his Mac.

Minecraft GBA port: Absolutely bonkers port to the Gameboy Advance.

The Incredible Overcomplexity of the Shadcn Radio Button: A look into how complex a single radio button is using shadcn.

Giving University Exams in the Age of Chatbots: An amazing article about how to handle education and exams in the age of Large Language Models.

I decided to make a worse UUID for the pettiest of reasons.: Redesigning UUID to improve developer experience. I especially like the 7 bits for type identification.

‘AI’ is a dick move, redux: This article summarises a lot of the pain points I’ve personally felt when discussing LLMs with people.

LLVM Adopts “Human In The Loop” Policy For AI/Tool-Assisted Contributions: A sensible approach to handling pull requests in the LLM era for open source software.

The Illusion of Intelligence: Large Language Models vs Human Cognition: I came across this article during a discussion on Slack for Ruby Australia and felt it summarises the technology behind LLMs excellently.

• Jekyll: I read the documentation and discovered the --future flag
• Taylor: New collision detection and a switch to LocalCI
• Simple.css: Using a new base CSS framework for this blog
• Interesting Links: Cool things I found this week

Jekyll

I use Jekyll to build this blog and one thing that’s always bugged me is that future dated posts and drafts didn’t show up in development. It turns out there is actually a flag for that; the --future flag. I’ve also enabled this flag when building the Docker image for production as my server time is quite a lot behind my local time and I like to publish my posts in the morning.

Taylor

Added Axis Aligned Bounding Box (AABB) collision for rectangles. This was the last collision I wanted to implement before doing a release.

AABB Pull Request

I have switched to LocalCI for testing needs. This has come with a bunch of library upgrades too. The biggest thing is probably migrating to using Clang 21 for clang-tidy and clang-format to keep things easily consistent across machines. I was getting really annoyed by my linting commands giving different results per machine and forcing me to use Docker to run the clang-format command.

LocalCI Pull Request

Simple.css

I’ve been looking for a good base Cascading Style Sheets (CSS) framework to build off of for a while now. Something that looks good by default but isn’t too opinionated and have too much stuff I’d need to override.

I stumbled across Simple.css and immediately liked it. As a trial run I’ve implemented it on my blog here. You may have noticed very slight differences. The main one being header sizes are a bit bigger. Overall there were very few changes I had to make and am really happy with it.

I know this is minor here but I’m hoping it will help with having a solid cross-platform base. The next project I’ll implement it in will be Taylor’s Playground as I know that has some issues on different browsers.

Interesting Links

Texudus: This is a social network that is incredibly close to the one I’ve theorised about. It’s a very interesting approach to a distributed social network.

An Introduction to Ruby Parsing with Prism: A great guide on how to use Prism to do interesting things with Ruby

15 Years of Indie Dev In 4 Bits of Advice: Interesting insights into how an indie game development company remains afloat

Announcing rv clean-install: rv is a tool to keep a close eye on

Doom WAD on a DAC: Just plain cool

RatatuiRuby: A port of Ratatui to Ruby. Yet another cool Text-based User Interface (TUI) framework for Ruby

Picotron Noodling: Making a small game prototype in Picotron

Xfce is great: Singing the praises for the excellent Xfce desktop environment

TruffleRuby 33 is Released: TruffleRuby gets a new release and switches to a different versioning system

• Ruby Squasher: Redesigning Taylor’s squash command
• Interesting Links: Cool things I found this week

Ruby Squasher

I got the itch to redesign the squash command in Taylor Engine because the current implementation leaves a lot to be desired.

The Way It Works Now

Given these three files.

# game.rb
require "lib/game"

Game.call()

# lib/game.rb
require "lib/player"

class Game
  def self.call
    puts "Run the game!"
  end
end

# lib/player.rb
class Player
  def self.call
    puts "Does player things"
  end
end

If we called taylor squash --stdout we would see the following code printed to standard output.

# Start game.rb
# Start ./lib/game.rb
# Start ./lib/player.rb
class Player
  def self.call
    puts "Does player things"
  end
end
# End ./lib/player.rb

class Game
  def self.call
    puts "Run the game!"
  end
end
# End ./lib/game.rb

Game.call()
# End game.rb

You can see that I’ve just replaced the require lines with the content from the files. This is actually very different to how require works under the hood and can lead to discrepancies between running in development and release builds. This is the big motivator behind redesigning taylor squash.

The Redesign

My plan is to distribute this as both a regular Ruby gem and an mruby mgem if I can get it to a point I’m happy with it.

The design I’m currently experimenting with is a bit more complicated but should lead to a more consistent operation between development and release. I would use lambdas to keep the namespaces clean and an overridden require method. I’ve put a functional example below to illustrate what the output could look like.

You can see this working in your browser.

#!/usr/bin/env ruby

SQUASHER_FILES = {
  "first_require" => -> {
    class First
      def self.call
        puts "First"
      end
    end
  },
  "second_require" => -> {
    class Second
      def self.call
        puts "Second"
      end
    end
  },
}

class Squasher
  def self.inject
    original_require = Kernel.method(:require)

    Kernel.define_method(:require) do |file|
      if Squasher.files.has_key?(file)
        Kernel.module_exec {
          Squasher.files[file].call
        }
      else
        original_require.call(file)
      end
    end
  end

  def self.files
    SQUASHER_FILES || {}
  end
end
Squasher.inject

require "first_require"

First.call

require "second_require"

Second.call

Running that will give you the following output.

First
Second

There’s definitely flaws with this but I think it’s a pretty promising start. I do also plan to squash files from gems into the output but would need to do something special for native gems.

Interesting Links

Create Your Own Programming Language with Rust Book: This book has been in development for 6 years and just released this week. I’ve had a strong desire to make my own language recently and this has only added fuel to that fire!

Writing Windows 95 software in 2025: A fun guide on setting up a development environment for Windows 95 on MacOS.

The Case for Blogging in the Ruins: Why blogs are still relevant and what needs they fill versus social media.

Pico-View 2025: Reflecting on everything that happened with PICO-8 during 2025. This is a magazine made by teachers and is always amazing, I absolutely recommend following them.

Portable mruby binaries with Cosmopolitan: I love seeing people doing interesting things with mruby and I had never heard of Cosmopolitan before.

How I beat Factorio on 1,000 Floppy disks: A YouTube video showing DocJade building a filesystem on top of 1,000 3.5” floppy disks and running Factorio from it.

How Github monopoly is destroying the open source ecosystem: A stark reminder that GitHub is a single point of failure and has warped people’s perspectives of open source software.