My name is Per

Tending to my personal music library

2026-02-01T19:32:34Z

I really started listening to music after I got an iPod Video for Christmas in 2005. I used that thing daily for around a decade. Being a weird nerd, my music collection initially consisted mostly of video game soundtracks, many of which were unofficial game rips done by fans like myself. For instance, I’ve always been a fan of the soundtrack to Croc: Legend of the Gobbos, a PS1 game that never got an official OST release (at least until the collector’s edition of the remaster eventually ships), so I made my own rip directly from the game disc. I spent a lot of time on the FFShrine forums looking for interesting soundtracks, and it’s truly a shame that it’s no longer around.

Around 2015, I felt smartphones had finally become good enough to replace my iPod, and they also offered new possibilities. The collection of MP3s that I had been building for a decade was uploaded in its entirety to Google Play Music, and I eventually moved to a Spotify subscription a few years later. I still wanted to listen to my weird MP3s, but importing local files to Spotify was a truly awful experience – probably because they didn’t actually want you to do it – so I soon moved to Apple Music instead. Its import feature wasn’t perfect, but it was a massive improvement coming from Spotify, almost like someone on the dev team actually cared about it.

I’ve been using Apple Music for around 5 years now, filling the gaps in its catalog with my own files, and overall I’ve been pretty satisfied. But as with any streaming service, when the license for a piece of media expires, you are no longer allowed to experience it. From one day to the next, your favorite song might disappear from your library without warning or recourse. It cements the fact that it’s not really your library; you’re just renting it on a monthly basis. A well maintained CD or vinyl collection can last a lifetime – and digital files are basically immortal when regularly copied to new physical media – but how much of your online music collection will survive the next 5 years? 10 years? 30 years? Your Spotify or Apple Music library is ultimately ephemeral, and its lifetime is dictated by a corporate machine with no regard for sentimental value.

Streaming services are built for convenience, not permanence. You get a constantly updated library of popular songs available on demand, and in return you sometimes have to let go of things you’ve already listened to. It’s a tradeoff that makes sense for casual listening, but what about the music you really care about? That one song you’ve listened to on repeat for weeks, or the one you enjoy rediscovering every few years? The album that makes you reminisce about a joyful past experience? Maybe those deserve better. Wouldn’t you sleep better knowing those couldn’t be taken away by something as nebulous as record label licensing agreements? Me too.

After years of prioritizing convenience I’ve returned to my MP3 collection, slowly expanding it and listening to it. While MP3 files work exactly the way they did 20 years ago, the technology around them has changed for the better. VLC or foobar2000 still work great, but with the help of Navidrome or Jellyfin you can get a personal, always-online streaming service without giving up on the permanence that local files provide.

For me, tending to my music library is a mix of nostalgia for a simpler time, digital preservation of art that matters to me, and nerding out about niche stuff like file organization and proper ID3 tags. In other words, right up my alley. There’s also a dash of self expression: I’m not building a music library that will be to everyone’s taste, but a curated, deeply personal one where every album has a reason for inclusion, or maybe even a story to tell. I find it a comforting activity, and I’m in no rush. This is a collection that’s been around for two decades, and I hope it stays around for at least another two.

Replacing Backblaze

2025-12-03T20:28:10Z

I’ve been a Backblaze customer since 2018 when a friend recommended their computer backup service to me, and for the most part I’ve been satisfied with it. Unlimited storage for 10€/month is pretty cheap and their software seems to work well, but that doesn’t mean a whole lot. The only people worth listening to when it comes to backup program recommendations are the ones who have successfully restored data with it in an emergency, and I’m lucky to not count myself among those. That means my general recommendation of Backblaze never carried much weight, but for what it’s worth I can recommend it no longer.

By complete accident, I noticed that at some point in October, Backblaze had stopped backing up files in iCloud Drive, even though I store its contents locally. For me, iCloud Drive might be one of the most important things to back up, something Backblaze has been happily doing for the past 7 years, so seeing it vanish from my backups was concerning to say the least. Looking into it I found a Reddit thread explaining that Backblaze version 9.2.2.878 silently stopped backing up cloud storage folders, among other things:

The Backup Client now blocks SSHFS-mounted drives and excludes system and cloud-synced folders like ~/Library/CloudStorage, Caches, Developer, Metadata, and Mobile Documents to prevent unintended backups and reduce data usage.

This is a frankly major change in functionality, and Backblaze apparently decided the best way to let their paying customers know was to bury it in a bullet point in a bunch of dry, technical release notes for an ordinary maintenance release of their software – under “Improvements” no less! It’s clear they’re not really interested in “preventing unintended backups” – there’s already a folder exclusion feature in Backblaze for this exact purpose – but I guess offering unlimited storage was a zero interest rate phenomenon.

What’s especially funny is that their own support site still has an article explaining specifically how to back up iCloud Drive, even though that feature is now removed. The Supported Backup Data article, linked to in the same release notes that , doesn’t mention cloud storage folders at all (as of 3 Dec 2025), and they’ve previously written about how Backblaze complements sync services since it also backs up cloud synced files.

Backblaze now does less for the same monthly price, which sucks. Having to find out by accident sucks even more. If I wasn’t some weirdo inspecting his automated backups, I would probably only find out when I needed to restore something, at which point it would no longer exist. I have more than one backup medium, of course. It’s going to be worse for those of us who have been sold the idea that Backblaze backs up your entire computer, when that claim becomes less true with each app update.

As I can no longer trust Backblaze to keep my data safe, I will not be renewing my subscription next month. So I found an alternative solution. The open source CLI program Restic has been on my radar for a while now because it seems to do a lot of things right:

it’s a single binary that runs on basically everything and uses standard backend protocols
its backups are encrypted, compressed, deduplicated and verifiable
it’s got a large community behind it making everything from GUI clients to centralized orchestration tools to re-implementations

As with Backblaze, my recommendation of Restic is basically irrelevant until I have experienced real disaster recovery, but what I can say is this: it’s very fast at backing up, and test restores have worked as they should. It’s also likely to survive in some state or another for a long time just due to the size of the community and the distinct lack of dependencies.

Unlike Backblaze, Restic comes with no predetermined backup destination. While I can easily use it to back up my computer to my NAS, I also need an offsite storage location in the unlikely event that my house burns down with the NAS inside. Since Restic works great with an SFTP backend, the most appealing option is currently a Storage Box from Hetzner (coincidentally, a provider I already use for other things). It’s supposedly just consumer hardware in some sort of RAID configuration, but you get 1 TB storage space, a few automated snapshots, and unlimited traffic for 4€/month, which is decently priced. You also get limited shell access, but it’s practically useless, so consider these boxes nothing more than remote filesystems.

I use the excellent Resticprofile wrapper to configure and schedule backups, and since Restic repositories are just regular folders, a repository can be easily rsynced offsite. For now, my backup system is not quite as smooth as the dedicated Backblaze app, and a plain 1 TB disk is not quite the same as the supposedly “unlimited storage” that Backblaze advertises, but at least this system doesn’t change its rules without notice.

Archiving media with Linkding

2025-08-16T05:56:26Z

Over the last year I’ve been getting into selfhosting apps on my own hardware. I’ve had a post about what that looks like in draft for a while now, and maybe you’ll see that at some point. But one thing I’m currently running is the Linkding bookmark manager.

I’ve tried Karakeep as well, but its UI just doesn’t feel right to me. What it does have going for it is the built in video archiving feature: if you bookmark a video, it’ll download an offline copy for you. Linkding does the same thing with HTML snapshots – and better than Karakeep, I might add – but it doesn’t treat media links in any special way, and an HMTL snapshot of a YouTube video page is pretty uninteresting.

Linkding has a REST API, so it’s got a sizable list of community projects built around it. I’ve now made one of the projects on that list: Linkding Media Archiver. It adds a Karakeep-esque video archiving feature by periodically scanning bookmarks for media links and handing them off to yt-dlp.

It adds the media files as attachments to the bookmark itself, so you don’t need a separate interface to retrieve them afterwards: it’s all there within Linkding.

Check it out if you’re a Linkding user!

LOK Digital trailer theme

2024-07-01T14:47:57Z

On June 8 I watched the Summer Game Fest 2024 live stream which showed off a lot of interesting indie games, including the puzzle game LOK Digital. The game looks cute and stylish (much like myself) but the thing that really stuck with me was the music used in the trailer.

The game isn’t out (yet) and there’s no official soundtrack to be found (yet), so I kept coming back to the trailer just to listen to it. My obsession with finding a clean version of the track led to me downloading the demo from Steam and the extracting its audio assets.

I found an audio track named “X” which is 3 minutes long and essentially contains two parts, the latter of which is a version of the trailer theme! Unfortunately, it’s not exactly the same, as the trailer version is faster and contains a different outro. But until the official soundtrack comes out (fingers crossed!), it might be as close as we can get.

~~I have cut it into an MP3 that you can find here.~~

Edit 2024-12-15: on December 11 the game and its official soundtrack was released, so go listen to that instead! The trailer theme is a sped-up version of the second half of the track called Sparks, and the rest of the soundtrack seems pretty cool too.

Seq on Railway

2024-06-09T18:47:08Z

I’m using Railway for some side projects. It’s like Netlify for traditional, non-serverless web apps, and it works really well: I can just push to git and the code is built and deployed, without having to worry about hosting infrastructure. It even supports structured logging by reading JSON-formatted logs directly from stdout.

But Railway’s built-in log explorer is pretty rudimentary, so you might want something more advanced if you’re dealing with a lot of logs. At work, we use Seq for application logging, and it too works really well: I can query structured logs with a flexible query language, set up dashboards and alerts, plot occurrences over time, and so on.

But until now, deploying Seq on Railway has been a bit of a pain. While Seq has an official Docker image, it needs a little configuration to make it work with Railway’s port binding and private networking features. My new template should make this process easier:

It contains a single service that spins up the Seq image from Docker Hub, but with some preconfigured options that should make it just work, as any Railway user would expect 😉

Adding Pagefind to an Eleventy site

2023-12-06T19:05:51Z

I just added Pagefind search to this site. Although it only just got bumped to stable, Pagefind is an elegant tool that solves a specific problem very well: adding search to static sites. It even comes with a decent default UI component.

This is a quick note on how to integrate it into an Eleventy site. There are already some posts on the subject but they all boil down to npx the Pagefind CLI in the eleventy.after build event. The CLI is fine if the site is large enough that indexing during development is annoying, but at that point it’s simpler to just run it with a package.json script. For 95% of sites, we can do better.

We’re still going to use the eleventy.after event, but we’re going to use the actual Pagefind Node.js API instead of executing shell commands. Pagefind needs to be imported asynchronously as it’s not a CommonJS module, but that’s really the only quirk you have to get past. Eleventy 3.0 will support ESM, so in turn you’ll be able to import it with regular import statements.

const path = require("path");

eleventyConfig.on("eleventy.after", async function ({ dir }) {
  const inputPath = dir.output;
  const outputPath = path.join(dir.output, "pagefind");

  console.log("Creating Pagefind index of %s", inputPath);

  const pagefind = await import("pagefind");
  const { index } = await pagefind.createIndex();
  const { page_count } = await index.addDirectory({ path: inputPath });
  await index.writeFiles({ outputPath });

  console.log(
    "Created Pagefind index of %i pages in %s",
    page_count,
    outputPath
  );
});

The API uses mostly the same defaults as the CLI so little configuration is needed. In this example we’re just indexing a directory of HTML files, but integrating Pagefind like this allows advanced usage as well. You could, for instance, customize file indexing on the fly using a linter, or index arbitrary data with custom records. Here’s an example that combines these to index specific parts of XML templates.

const path = require("path");

let index;

eleventyConfig.on("eleventy.before", async function () {
  const pagefind = await import("pagefind");
  index = (await pagefind.createIndex()).index;
});

eleventyConfig.addLinter("index-content", async function (content) {
  if (this.outputPath?.endsWith(".xml")) {
    await index.addCustomRecord({
      url: this.page.url,
      content: getSearchableText(content), // Some assembly required
      language: "en",
      meta: { title: getTitle(content) },
    });
  }
});

eleventyConfig.on("eleventy.after", async function ({ dir }) {
  const outputPath = path.join(dir.output, "pagefind");
  await index.writeFiles({ outputPath });
});

Then it’s just a matter of adding the default UI somewhere and everything will just work™ when building the site – even in --serve mode.

Building for Gemini with Eleventy

2023-11-08T21:24:54Z

I recently discovered Gemini, an interesting lightweight alternative to HTTP, complete with its own markup language called Gemtext. While it’s only a couple of years old at this point, it’s supposedly inspired by the Gopher protocol. I’ll have to take their word for it – Gopher died off before I started using computers. I love the possibilities afforded by the modern web, but I can understand yearning for an online experience that isn’t dominated by 25 MB page loads and cookie consent popups. Sometimes I wish I could browse the web entirely in Reader mode, and Gemini basically says “what if everything was like that by default?” It’s too minimalist to ever take off – and arguably too elitist – but Gemini is an interesting vision of what the web could have been if only we as a species could settle for less.

As a side project, I wanted to try bringing permortensen.com into Geminispace – a capsule in local parlance. I already use a static site generator called Eleventy to build this site, which is mostly a bunch of Markdown files and some HTML layouts. Eleventy usually transforms content into HTML, but it’s flexible enough to output pretty much any format – like Gemtext – if you tweak it enough. Some requirements for the Gemtext version:

It has to use the same Markdown files without modification, as I don’t want to update every page and blog post
It has to slot into my existing .eleventy.js configuration and be enabled with a single toggle, like an environment variable
Both HTML and Gemtext builds have to produce a ready-to-publish output directory, as I don’t want any extra steps to my deployment workflow (I just push to main)

The rest of this post documents the process of adapting my site for Gemini. I couldn’t find any existing guides on the topic, so I wanted to share what I found out in case anyone else finds it interesting. Geminispace could probably use some more content…

Project layout

For the existing HTML site, my source directory structure looks something like this

permortensen.com/
  _layouts/
    default.html
    post.html
  _posts/
    post1.md
    post2.md
    ...
  .eleventy.js

Every post uses a layout template called post, which renders the title and date from the post’s front matter. This template itself uses a layout called default, which renders the <head> and <body> elements around it. These .html files are really Liquid templates that just happen to contain HTML. The .md files also contain some Liquid tags, such as for eleventy-img, so they are preprocessed with Liquid as well. This works out of the box, as Eleventy preprocesses both HTML and Markdown files with LiquidJS by default (probably to align with Jekyll, the OG static site generator).

About Gemtext conversion

Like HTML 30 years ago, Gemtext is all about documents linking to other documents, but with a tiny vocabulary. Whereas all of Markdown can translate into HTML, only a fraction of it can translate to Gemtext. There is no syntax for images, text decoration, or even inline links – every link has to occupy its own line, and its solution to showing an image is simply linking to one. These limitations make for a very consistent browsing experience but also makes Gemtext conversion a lossy operation, even if you’re using the absolute basics of Markdown syntax.

The most promising Markdown to Gemtext converter I’ve found is md2gemini, which is a Python module available on PyPI. It’s archived, but as of writing it still seems to work pretty well – I guess neither Markdown nor Gemtext have changed significantly since. Honorable mention to gemgen, which is similar but unfortunately has some bugs when rendering lists with links. Both projects do clever things to work around the limitations of Gemtext: Markdown links inside a paragraph are extracted and listed below it with their original label preserved, while images are replaced with an image link labeled by its alt text. It’s probably the best automated approach to this problem, though it can lead to some weird looking links when pulled out of their original context.

For instance, the paragraph you’re reading right now has a link in it. That would end up as the Gemtext

For instance, the paragraph you're reading right now has a link in it. That would end up as the Gemtext

=> https://example.com/    a link in it

which isn’t ideal. Some would argue that this is the wrong way to label your links anyway (and I would agree!), but it probably needs some getting used to even for hyperlink purists. md2gemini can also extract links as numbered footnotes, but then every link is unreadable on its own.

md2gemini can be installed with pip install md2gemini, if you have Python 3 installed. As Eleventy runs on Node, there’s no built-in way to bundle Python modules. My current approach is to just install md2gemini globally with pip, which is not ideal. You could presumably install it using a Python package manager invoked from a package.json post-install script, but then you’d still need to install Python. However you do it, the rest of this post assumes a working installation of md2gemini.

Generating Gemtext from Markdown content

Eleventy by default uses markdown-it to turn Markdown into HTML, but we now want md2gemini to turn Markdown into Gemtext instead. This is possible by overriding the engine for md files, passing Markdown to a child process through STDIN, and reading back Gemtext from STDOUT. Here I’m using the --plain switch to remove any inline text decoration syntax, which will otherwise render literally in Gemtext.

const { execFile } = require("node:child_process");

eleventyConfig.addExtension("md", {
  outputFileExtension: "gmi",
  compile: async function (inputContent) {
    return async (data) => {
      const gemtextContent = await new Promise((resolve, reject) => {
        const process = execFile(
          "md2gemini",
          ["--plain", "--links", "copy"],
          (error, stdout) => (error ? reject(error) : resolve(stdout))
        );
        process.stdin.end(inputContent);
      });

      return gemtextContent;
    };
  },
});

Unfortunately, overriding the default Markdown engine also disables the automatic Liquid preprocessing, so the output will contain raw Liquid syntax, if any. To fix this, we have to manually invoke LiquidJS, which will render to real Markdown. I can’t find a way to grab the built-in LiquidJS instance, so as a workaround we can tell Eleventy to use a custom instance and then use it to preprocess the templates ourselves. Eleventy will register any custom tags and filters on the instance you give it, so they should work the same in both built-ins and our custom Markdown-to-Gemtext engine.

const { execFile } = require("node:child_process");
const { Liquid } = require("liquidjs");
const liquid = new Liquid();

eleventyConfig.setLibrary("liquid", liquid);

// eleventyConfig.addFilter('post_url', ...);
// eleventyConfig.addShortcode('image', ...);

eleventyConfig.addExtension("md", {
  outputFileExtension: "gmi",
  compileOptions: {
    permalink: "raw",
  },
  compile: async function (inputContent) {
    return async (data) => {
      const markdownContent = await liquid.parseAndRender(inputContent, data);
      const gemtextContent = await new Promise((resolve, reject) => {
        const process = execFile(
          "md2gemini",
          ["--plain", "--links", "copy"],
          (error, stdout) => (error ? reject(error) : resolve(stdout))
        );
        process.stdin.end(markdownContent);
      });

      return gemtextContent;
    };
  },
});

By default, Eleventy will also attempt to render the permalink of each page using the page’s template engine to allow for dynamic permalinks. While it would be feasible to pass the links through Liquid alone (and skip Gemtext conversion), I’m not using dynamic permalinks and set permalink: "raw" to disable the feature altogether.

Now we’re transforming Markdown to (pretty decent) Gemtext. _site contains a bunch of .gmi files as expected, but they all contain a bunch of HTML around our content. What gives?

Replacing HTML layouts

It’s the layouts. While the Markdown files now transform into Gemtext, the layouts are written in HTML and can’t meaningfully reduce to Gemtext. We’ll have to replace the HTML layouts with Gemtext equivalents, by hand. For instance, _layouts/post.html gets a sibling called _layouts/post.gmi.

---
layout: default
---
# {{ title }}

Posted {{ page.date | date }}

{{ content }}

These are still just Liquid templates, except now they happen to contain Gemtext instead of HTML. As Gemtext has no concept of metadata or graphical layout, default.gmi will likely just consist of {{ content }} and perhaps some primary navigation links.

To make Eleventy use the .gmi layouts instead of the .html ones, we register gmi as an alias of liquid to get automatic Liquid rendering for .gmi files. We also remove html from the list of valid template formats in order to avoid processing the HTML layouts altogether. I haven’t found a way to actually remove it other than setting the template formats to a list where html is absent.

eleventyConfig.addExtension("gmi", { key: "liquid" });
eleventyConfig.setTemplateFormats(["md", "liquid"]);

Assuming all layouts are referenced without a file extension, these two lines replaces every HTML layout with its Gemtext equivalent without any modifications to content or front matter. Neat!

Odds and ends, bits and bobs

You might have noticed that I’ve been using only the configuration API for the entire thing, and there’s a reason for that. With this centralized approach, it’s straightforward to toggle Gemini behavior on and off in .eleventy.js, like with this environment variable.

module.exports = function (eleventyConfig) {
  // Common configuration here

  if (process.env.GEMINI) {
    // Gemini specific configuration here
  } else {
    // HTML specific configuration here
  }
};

Other things to consider customizing via this toggle:

CSS, as you can’t style Gemtext pages
Client-side JavaScript
Favicons and Open Graph images

If you’re publishing an RSS/Atom feed, there is a proposed convention for a Gemini equivalent, but some clients like Lagrange will automatically convert a regular feed for you. Such a feed will contain HTML links unless customized, which could be done by copying the toggle to a global JavaScript data file or configuration global data and then adapting the feed template accordingly.

eleventy-img generates HTML by default, which needs to be replaced. Gemtext conversion will turn any Markdown images into links, so {% image ... %} shortcodes should render as regular Markdown images instead of <img> or <picture> tags.

eleventyConfig.addShortcode("image", async (src, alt) => {
  const pluginImage = require("@11ty/eleventy-img");
  const metadata = await pluginImage(src);

  if (process.env.GEMINI) {
    const data = metadata.jpeg[metadata.jpeg.length - 1];
    return `![${alt}](${data.url})`;
  }

  return pluginImage.generateHTML(metadata);
});

As neither Markdown nor Gemtext supports responsive images, we’ll have to settle on a single image format – here I’ve chosen the highest quality JPEG for maximum compatibility.

Eleventy has a built-in convention where if a page’s permalink ends with /index.html, the filename is automatically removed for a nicer looking URL. This is HTML specific, so generated links, as well as the built-in page.url property, will end in /index.gmi. The behavior can be replicated for Gemtext using the (poorly documented) URL transform feature.

eleventyConfig.addUrlTransform(({ url }) => {
  const pattern = /\/index\.gmi$/i;
  return url.match(pattern) ? url.replace(pattern, "/") : undefined;
});

Eleventy is very flexible and no two setups are the same. There’s probably a bunch of edge cases that I haven’t considered (or even encountered), but this should get you most of the way.

Hosting and deployment

We’re spoiled for choice when it comes to web hosting. Netlify, Vercel, Cloudflare Pages, and countless others make static website hosting a breeze by automatically building and deploying on every git push. While these services could easily build a Gemini capsule, they wouldn’t be able to host it. With them, HTTP is not only the default. It’s the only protocol in town. Gemini is a different protocol altogether, which is not supported by any of the mainstream providers and pretty much requires a box running some sort of Gemini server program (which there is no shortage of).

You could do this on a Raspberry Pi or your home computer if you really wanted to, and it would certainly fit the “smol web” ethos. My current approach is a $5 Linode VM that runs Agate in a tmux session, coupled with a GitHub Actions workflow that builds the site with GEMINI=1 and deploys it with rsync. It’s the simplest approach I could find that doesn’t require me to do anything extra to deploy: I just push to main and the site updates itself in turn. The following workflow is inspired by a good blog post on the topic.

on:
  push:
    branches: ["main"]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: "npm"
      - uses: actions/setup-python@v4
        with:
          python-version: "3.9"
      - uses: shimataro/ssh-key-action@v2
        with:
          key: ${{ secrets.GEMINI_SSH_KEY }}
          known_hosts: ${{ secrets.GEMINI_KNOWN_HOSTS }}
      - run: pip install md2gemini
      - run: npm ci
      - run: npx eleventy
        env:
          GEMINI: 1
          NODE_ENV: production
      - run: rsync -avh --delete ./_site/ $HOST:$CONTENT/
        env:
          HOST: ${{ vars.GEMINI_HOST }}
          CONTENT: ${{ vars.GEMINI_CONTENT }}

So for now, permortensen.com has a presence in Geminispace as well. If I’m still hosting the Gemini capsule by the time you read this – and I haven’t broken it somehow – you can find it at gemini.permortensen.com. Adapting the site for an alternative platform has been a fun challenge, and I hope this post inspires you to give it a shot as well.

The semi-automatic robot vacuum

2023-07-17T17:36:02Z

I was recently given a Roborock S7 robot vacuum cleaner. It’s an indulgence, really. We’ve got 78 m2 of floor space so automated vacuuming really isn’t necessary. But for the first time in years, I’m living in a place that uses one continuous floor with no steps between rooms, which is the ideal condition for such a device. We’ve nicknamed it Rocky after it started — and lost — a fight with our clothes drying rack.

As previously noted, I use Home Assistant to tie my smart home stuff together. When I got Rocky, the only way to connect it to Home Assistant was through the Xiaomi Miio integration, which required using the Mi Home app rather than the Roborock one. The 2023.5 release of Home Assistant introduced a dedicated Roborock integration which is… mediocre. It actually seems to have a lot fewer features than the old one, so switching was a bit underwhelming. But they’re promising more features down the road, and I suppose there’s now a mop intensity dropdown available.

Of course, you don’t integrate with Home Assistant for manual control; it’s the potential for automation that makes it worthwhile. My dream was to make Rocky totally autonomous: I would have it clean the entire apartment every few days when no one was home, requiring no effort on my part. It would be a real home of the future. It’s technically possible to do, but the reality is that we’re giant slobs who leave our clothes all over the bedroom floor, and despite his willingness to try, Rocky can’t actually swallow a pair of jeans. Oh, and I guess the dustbin needs to be emptied once in a while, as I’m too much of a cheapskate to get the self-emptying dock. Yes, there’s a limit to my indulgences.

So I have to actually know when the thing will run so I can prepare the place. What I really needed was a semi-automatic automation that could start cleaning when no one is home, but required a manual go-ahead first. And it should allow skipping some rooms to avoid another altercation with the drying rack. With the current state of the Roborock integration, getting this in order was a multi-step process that involved a heavily templated script and some helper entities. I’m gonna explain how I did it here.

Helper entities

First, I set up a number of boolean helpers that control which rooms should be included when cleaning, as well as an Auto clean boolean that is used as a condition for the automation to run (which we’ll get to). It looks like this on my Lovelace dashboard:

Selective room cleaning script

The helpers are used in a script that sends a “start cleaning” command to the Roborock integration. This command is either a “selective room cleaning” command if any of the room toggles are on, or a general “clean everything” command otherwise. Selective room cleaning requires figuring out technical identifiers for each room, which is currently an elaborate process, so that’s the first step.

The following script uses an unsightly mix of YAML and Jinja syntax to transform the states of the room booleans into a list of Roborock room identifiers for the app_segment_clean command. I’m abusing the Jinja templating to write out a string that happens to be parseable a YAML list, by concatenating comma-separated numbers and then chopping off the final comma.

alias: Selective room cleaning
sequence:
  - if:
      - condition: or
        conditions:
          - condition: state
            entity_id: input_boolean.clean_office
            state: "on"
          - condition: state
            entity_id: input_boolean.clean_living_room
            state: "on"

          # ... other rooms omitted ... #
    then:
      - service: vacuum.send_command
        data:
          command: app_segment_clean
          params:
            - segments: |
                {%- set rooms = "" -%}
                {%- if is_state('input_boolean.clean_office', 'on') -%}  
                  {%- set rooms = rooms + "16," -%}
                {%- endif -%}
                {%- if is_state('input_boolean.clean_living_room', 'on') -%}
                  {%- set rooms = rooms + "17," -%}
                {%- endif -%}

                # ... other rooms omitted ... #

                [ {{ rooms[:-1] }} ]
            - repeat: 1
        target:
          device_id: 9b283511d92e17bf340dbeb97fc90d3e
    else:
      - device_id: 9b283511d92e17bf340dbeb97fc90d3e
        domain: vacuum
        entity_id: vacuum.rocky
        type: clean
mode: single

Automating script execution

The final step is invoking the script from an automation. It also turns off the helper so it won’t run again without manual intervention. I’ve currently set it to run when all of the following are true:

The home has been vacant for 10 minutes
The Auto clean helper is on
Rocky is docked

alias: "Away for 10 minutes: start cleaning"
trigger:
  - platform: numeric_state
    entity_id: zone.home
    below: 1
    for:
      hours: 0
      minutes: 10
      seconds: 0
condition:
  - condition: state
    entity_id: input_boolean.auto_clean
    state: "on"
    enabled: true
  - condition: device
    device_id: 9b283511d92e17bf340dbeb97fc90d3e
    domain: vacuum
    entity_id: vacuum.rocky
    type: is_docked
action:
  - service: script.turn_on
    data: {}
    target:
      entity_id: script.selective_room_cleaning
    enabled: true
  - service: input_boolean.turn_off
    data: {}
    target:
      entity_id: input_boolean.auto_clean
    enabled: true
mode: single

With all this, I can set Rocky up for success by moving stuff off the floor and turning on Auto clean, which starts cleaning once everyone has left. Is this too much work for something like this? Yes. But overcomplicating is kinda my thing.

Obsidian Trash Explorer

2022-11-13T17:15:01Z

Just a quick note that I’ve published my first Obsidian plugin: Obsidian Trash Explorer.

I still use Bear as my primary notes app, but I’m getting increasingly interested in Obsidian as the plugin ecosystem gains traction and the UX continues to improve. The app recently had a major visual overhaul for version 1.0, which made me take a closer look.

Smart Home Automations

2022-06-11T13:30:47Z

A few years ago, I bought a Philips Hue starter kit on a whim. Since then, I have replaced all my lightbulbs with Hues and have been getting into the whole smart home thing. Many people see smart home tech as a gimmick, and I don’t blame them: most people who dip their toes into this space buy a Google Home and a couple of smart bulbs, and then leave it at that. You can now ask Google to turn the lights on, and it only takes twice as long as flipping the lightswitch. Truly the home of the future. No, the real value of connected devices is the ability to integrate them and automate everyday things and have fewer first world problems to deal with. That’s where Home Assistant shines – it integrates with almost anything. Here are a couple of things I do with my setup.

Lights on for multiple people

Like everyone with smart lights, I have an automation that turns on the light when I come home after dark. Where most automations fail in this area is dealing with more than one person in the home.

My old apartment was fitted with Hue bulbs in every socket, and I had a standard Hue app automation that turned on all the lights when my phone was close to home. One evening, my girlfriend was staying at my place and had gone to bed while I was out. When I arrived a hundred meters from my place, the automation helpfully turned on all the lights and jolted her awake. Imagine being alone and half-asleep when all your lights come on for no apparent reason. That would certainly make me uneasy.

I didn’t want to repeat that, so in Home Assistant, I have an automation that only turns on the lights if no one is already at home. This feature has since been added to the Hue app, but I automate more than just lights: my Netatmo radiator valves also lowers their target temperature when everyone leaves. Also, the lights only come on if it’s actually dark out.

In previous versions of Home Assistant, detecting if someone was already home was a bit convoluted. You’d have to create person groups in YAML and rely on a quirk where the trigger of the automation detected a state change before a condition would reflect it, but in version 2022.4, it’s as simple as triggering on a zone state change from 0 to 1 and vice versa.

trigger:
  - platform: state
    entity_id: zone.home
    from: "0"
    to: "1"
condition:
  - condition: or
    conditions:
      - condition: sun
        before: sunrise
      - condition: sun
        after: sunset

Electricity price monitor

A few months ago, I made a forecast graph of the hour-by-hour electricity price with data pulled from Nord Pool, which lets me schedule power-hungry tasks for when it’s cheaper. Now I’m considering ways to collect long-term usage stats to see if we’re actually getting anything out of it. The other day I showed the graph to my friends, who were… well, let’s just say they weren’t as excited about it as me. This weird fascination is something I must have inherited from my dad; he had a habit of tracking this kind of stuff in excruciating detail. I used to think it was pretty lame, but after he passed away last year, I take comfort in the fact that I inherited some of his lameness.

In Home Assistant, I have embedded the graph on a dashboard running on an ancient 7 inch tablet that sits in my closet. The thing is actually so old it can’t run the Home Assistant app, but it can open the web interface in Chrome, which is good enough. The graph I use is hosted here, and the source code is available on GitHub. Note that it’s currently hardcoded to pull prices for the DK2 region (eastern Denmark).

E-bike battery charging

I have been riding bikes my whole life and I enjoy it. My last few jobs have given me a longer commute than I’m willing to make on a normal bike, so I have one with an electric motor. I use it daily for work, but the battery can only do one roundtrip on a single charge. Previously, I would charge it as soon as I got home, but as long as it’s ready in the morning, I don’t care when. Since power is usually cheaper at night, I’ve set up an automation that turns on the charger with a Shelly smart plug at 1 AM, and turns it off again when it’s done. On my tablet dashboard, it looks like this:

The automation depends on a software toggle, as I don’t usually use the bike on weekends or when it’s raining. To avoid turning on the charger for no reason, the automation itself turns off the toggle after it’s done. At first, I had set it up so I had to manually enable it every day when I got home. One day I forgot to do that, and I was met with no juice the next morning. Something had to be done.

Ideally, the system would detect if my bike had left (and later returned) and flip the toggle. I had already duct taped an AirTag to it (very stylish), but AirTags can’t yet be tracked by Home Assistant. As an alternative, I set up a passive zone at a point on my commute that I don’t otherwise visit, and flip the toggle if my phone enters it. That means that when I’m biking to work, the charger is automatically primed for charging, but if I take the train or work from home, the charger stays off. Some days, I bike to work, take the train home, and only bring the bike home the day after. To account for that, the zone only triggers in the afternoon.

The “optimal charging start time” entity in the screenshot is an additional automation I’m working on that will eventually plan the best charging time by itself. It works like this:

Get the electricity price forecast
Find the cheapest 4 hour timespan that ends before 6 AM (when I usually wake up)
Schedule the battery charger automation to run at that time

I’m just testing it out for now, which is why it’s just shown on the dashboard. The logic is exposed as a serverless function with my graph and Home Assistant polls it like this:

rest:
  - scan_interval: 3600 # 1 hour
    resource: "https://elspot.per.computer/cheapest-range"
    params:
      hours: 4
      maxEndTime: >
        {{ (today_at("06:00") if now() < today_at("02:00") else today_at("06:00") + timedelta(days=1)).isoformat() }}
    sensor:
      - name: "Optimal charging start time"
        value_template: "{{ as_local(as_datetime(value_json.startTime)).time() }}"

VS Code keymap for Obsidian

2021-09-24T17:43:00Z

I recently got the chance to try out Obsidian, and while it’s still in dire need of some UX polish, it strikes me as a very promising project that aligns well with my personal philosophy of what a notes app should do. Perhaps one day it will replace Bear as my favorite notes app.

While the editor looks superficially like the one in Visual Studio Code it differs quite a bit in its default keyboard shortcuts, which is annoying if you use both apps regularly. Obsidian’s shortcut system is not quite as sophisticated as Code’s (for instance, key sequences are not supported) but I’ve done what I can to make Obsidian behave more Code-like. In particular, remapping the quick switcher and command palette to Cmd+P and Cmd+Shift+P, respectively, is a small change that makes a big difference.

Here’s my current Obsidian keymap customizations. You can copy some or all of them into .obsidian/hotkeys.json inside each vault.

{
  "editor:swap-line-down": [
    {
      "modifiers": ["Alt"],
      "key": "ArrowDown"
    }
  ],
  "editor:swap-line-up": [
    {
      "modifiers": ["Alt"],
      "key": "ArrowUp"
    }
  ],
  "command-palette:open": [
    {
      "modifiers": ["Mod", "Shift"],
      "key": "P"
    }
  ],
  "switcher:open": [
    {
      "modifiers": ["Mod"],
      "key": "P"
    }
  ],
  "editor:delete-paragraph": [
    {
      "modifiers": ["Mod", "Shift"],
      "key": "K"
    }
  ],
  "workspace:close-others": [
    {
      "modifiers": ["Alt", "Mod"],
      "key": "T"
    }
  ],
  "workspace:copy-path": [
    {
      "modifiers": ["Alt", "Mod"],
      "key": "C"
    }
  ],
  "file-explorer:open": [
    {
      "modifiers": ["Mod", "Shift"],
      "key": "E"
    }
  ],
  "editor:toggle-bold": [
    {
      "modifiers": ["Mod", "Shift"],
      "key": "B"
    }
  ],
  "app:toggle-left-sidebar": [
    {
      "modifiers": ["Mod"],
      "key": "B"
    }
  ],
  "editor:focus-left": [
    {
      "modifiers": ["Mod"],
      "key": "1"
    }
  ],
  "editor:focus-right": [
    {
      "modifiers": ["Mod"],
      "key": "2"
    }
  ],
  "app:go-back": [
    {
      "modifiers": ["Ctrl"],
      "key": "-"
    }
  ],
  "app:go-forward": [
    {
      "modifiers": ["Ctrl", "Shift"],
      "key": "-"
    }
  ]
}

hotkeys.json on GitHub

Automating Bear notes backup

2021-06-05T16:15:00Z

All note apps suck in some way or another. Apple Notes is too basic, Notion is too slow, Obsidian is too intimidating. For me, Bear currently strikes a nice balance between usability (well designed apps) and openness (first-class Markdown support, easy export). Bear is not perfect; it’s Apple-only, and the editor lacks some Markdown features, but I use it daily and like it a lot (and they’re apparently working on both issues).

As my collection of notes grows, it should naturally become part of my backup process, which consists of a homegrown shell script that backs up a number of things, including databases, cloud storage and personal files. While Bear has a handy backup/restore feature in both the macOS and iOS app, it has no CLI I can use from my script. The only supported way to make a backup is through its GUI.

Sure, you could easily make a copy of the underlying SQLite database, but there’s no guarantee Bear can open it a year down the line after updates have migrated the database schema, and it’s pretty unintuitive to work with directly should Bear no longer be around. Bear’s own backups, meanwhile, are just zips of TextBundle files, which makes recovery easy both in- and outside of Bear.

So here’s an AppleScript for macOS that automates the clicks and keystrokes needed to back up notes through Bear. It can be run directly from a terminal or shell script and waits around for the backup process to complete, so the file will be ready when the script exits. The whole thing does rely on some pretty shaky assumptions about the Bear interface, but GUI automation is, as always, notoriously brittle.

Important: Make sure the backup directory exists. It will not be created for you.

#!/usr/bin/osascript

set backupPath to "~/Desktop/"
set osVersion to {system attribute "sys1", system attribute "sys2", system attribute "sys3"}

-- Launch/switch to Bear
set previousFrontmostApp to (path to frontmost application) as text
activate application "Bear"
repeat until application "Bear" is running
    delay 0.5
end repeat
delay 0.5

tell application "System Events"
    tell process "Bear"
        click menu item "Backup Notes..." of menu "File" of menu bar 1

        -- Wait for the file dialog to appear
        repeat until window "Please choose the location where the notes will be saved" exists
            delay 0.5
        end repeat
        delay 0.5

        tell window "Please choose the location where the notes will be saved"
            -- Use the Cmd+Shift+G "go to folder" shortcut
            keystroke "g" using {command down, shift down}

            -- Wait for the "go to folder" window to appear
            repeat until sheet 1 exists
                delay 0.5
            end repeat
            delay 0.5

            -- Navigate to the backup folder
            tell sheet 1
                if item 1 of osVersion < 12 then
                    -- Classic "go to folder" dialog
                    set value of combo box 1 to backupPath
                    click button "Go"
                else
                    -- Monterey updated "go to folder" to a Spotlight-esque command palette
                    set value of text field 1 to backupPath
                    key code 36
                end if
            end tell

            -- Wait for the "go to folder" window to close
            repeat while sheet 1 exists
                delay 0.5
            end repeat
            delay 0.5

            click button "Export notes"
        end tell

        -- Wait for the untitled backup progress window to appear, then close
        repeat until window "Window" exists
            delay 0.5
        end repeat
        repeat while window "Window" exists
            delay 0.5
        end repeat
    end tell
end tell

-- Switch back to previously activated app
activate application previousFrontmostApp

backup-bear-notes.applescript on GitHub

Update 2022-03-14: Updated script to be Monterey-compatible.

Official treats for official beasts

2021-02-12T17:36:00Z

Last year, I wrote about my obsession with treatsforbeasts and especially its weird music.

Well, a new album just dropped, and it’s a compilation of the original music used in every major treatsforbeasts video, including I Love the Sound of Screaming Babies and the popular Beasts. This makes my unofficial upload of the former obsolete, so I’ve deleted it from the post.

Besides the magnificent Roii song, I’m particularly interested in what the album calls Daddy’s a Freak, an instrumental track used in the 2017 TreatsforBeasts video that’s partly a both ominous and hopeful chant and partly a slow piano rendition of the climactic synth riff from the older beasts video.

As I don’t have anything else to add, I guess this is little more than an unpaid advert for the album. Go listen to it if you’re into that kind of thing.

Tracking down an obscure album

2020-09-08T18:48:00Z

Sometime in 2016 I was playing Elite: Dangerous and listening to Radio Sidewinder when a gorgeous track came on. Turned out this track was Childhood by Belgian trip hop group Airlock, and I wanted to listen to it again. Usually, I’d either find it in a torrent, on some shady Russian mp3 sharing site, or maybe even buy it with actual money like a decent person. With this track, and the album it’s on, it’s not quite that easy.

Airlock was active in the early-mid 2000’s and released two studio albums around this time — Drystar from 2002 and Symptomatic from 2004 — as well as a soundtrack album for a movie called The Room (no, not the famous one, it’s actually this one that you haven’t heard of). These albums are widely available, but none of them contain Childhood. That track happens to be from a fourth release from 2005: the soundtrack for the documentary The Long Journey Home. It’s listed on the band’s extremely stubby Wikipedia article, but MusicBrainz doesn’t know about it, and it’s also not listed on any store page, torrent site, or low quality MP3 site I can find. What.cd, back when it was still in operation, didn’t have or mention it. Airlock’s own website, when I researched it in 2016, had last been updated in 2004 and so predated the album (and is now defunct). It’s pretty obscure.

It does have a couple of references around the web, though. Discogs lists it, and trip-hop.net, a French music review site, contains a 2005 article about it. I couldn’t read French to save my life, but thanks to some dodgy machine translation the article gives us this juicy bit of info:

Just a few months after the release of “Symptomatic” which had confirmed the group as an ascending value of Belgian trip-hop, a press release from the group informs us of a new release, which is in fact film music!
. . .
Good luck finding this album, however, because it is not scheduled for sale … but can be won on Trip-Hop.Net thanks to Airlock which keeps us some for you! A rare and very precious collector …

So it looks like The Long Journey Home is indeed not available anywhere except in a giveaway on a French music site… 15 years ago. Despite the “nostalgic” look of trip-hop.net, the site is still in operation, so I contacted trip-hop management, who confirmed it.

Hey,
apparently the album wasn’t released, but available in very few copies and Airlock offered some via a contest on trip-hop.net.
I can’t share the name of the winners, but I’m trying to get some infos among the oldest members of our redaction. Maybe they have some tips to find a copy.
best regards from France !

After this exchange, months went by, and they never contacted me again. I contacted Radio Sidewinder’s admin and their music provider Radionomy. I contacted Airlock member Ernst Meinrath, who in 2012 uploaded a trailer for the documentary that actually starts out playing Childhood. No success.

But it turned out the answer had been right in front of me the whole time. I realized the album’s Discogs page was oddly detailed compared to every other mention of its existence, and a single user did claim to own it. This one owner turned out to have found it on eBay after searching for it for years, and he was kind enough to send me the audio.

This all took place in 2016, and I’ve had a draft about it lying around since, mostly because I didn’t know how to end it. It felt wrong to just go and share the album, which is to my knowledge still quite rare. But without something to show for all my effort, the story just felt extremely unsatisfying. After a good 4 year ponder I’ve now decided to at least share the track that started it all. Here’s Childhood by Airlock.

A Treat for Beasts

2020-03-25T10:32:00Z

The most annoying thing about watching the amount of YouTube that I do is that I’m into a bunch of weird creators with no one to discuss them with. One of them is treatsforbeasts, an enigmatic creator dabbling in the intersection of music, comedy, and the macabre.

Treatsforbeasts’ productions are generally unpredictable, with their last 5 videos uploaded years apart and featuring a mix of cartoons, original music, and comedy skits. My current favorite has to be the 2017 video TreatsforBeasts because of its impressive diversity and production value. While the most recent video, The Beast Is Dead, is similar in style, dedicating half its runtime to an extended skit of questionable quality brings it down somewhat. However, just before the halfway point, there’s a 4 minute long music video for the song I Love the Sound of Screaming Babies by a fictional artist called Roii. The video works well as a humorous parody, but the song itself is legitimately a banger, and in my COVID-19 isolation I’ve caught myself singing it way too often.

To my huge disappointment, I Love the Sound of Screaming Babies by Roii is nowhere to be found outside treatsforbeasts’ video. At least not online; I’m currently unable to check petrol stations in Slovania. But I can’t help it: I really want to listen to Roii’s beautiful voice on the go. To that end, I’ve extracted an mp3 version myself:

(Edit 2021-02-12: There’s now an official version out, so the link has been removed)

This is obviously copyright infringement, but I hope treatsforbeasts will be alright with it. Being sourced from a YouTube video, the audio quality is not ideal, and I hope treatsforbeasts will one day release an official, high quality version.

whatever.sh

2020-03-14T11:31:00Z

I made a tiny new project!

We have upwards of 30 code repositories at work, and I consistently run the same commands every time I return to each of them. First I do a git fetch so I know what branches people are working on, then I do a git pull to make sure my local branch is up to date. Then I usually do a dotnet restore (we primarily do .NET at work), and only then am I ready to start doing whatever I came in there to do.

I do this with my collaborative hobby projects too, and now that GitHub makes automated pull requests for security updates, even my private repositories aren’t safe from going out-of-date. And while I do .NET at work, my personal repos are much more diverse, requiring a bunch of different tools to make them usable.

So I made a script to automatically get the repo into a usable state: whatever. It’s called that because that’s how I feel about running these housekeeping commands: just do whatever, man.

I would really like to add more features to it, but since it’s based on my own usage patterns, I’ll have to keep an eye out for stuff I still end up doing after whatever.

Let's fix FFXII's save UI

2019-11-22T17:30:00Z

I don’t know much about good user interface design. I’m not quite User Inyerface clueless, though I’m probably not far off either. But stick with me here, because what follows is an example of bad UI that should be obvious enough that anyone would say “yeah, that’s some bad UI.”

Let me start by saying that I absolutely adore Final Fantasy XII. I’ve only played through it 1.5 times, but I would defend it to death just the same. It breaks enough established (and bad) Final Fantasy-isms that it stands out from the rest. It has the least annoying battle system, the most intriguing world, and even the most beautiful music of the entire series. Yes, the awkward FF dialogue is still there, but for once it actually seems intentional. I firmly believe it to be the best Final Fantasy game ever made.

The 2017 PS4 remaster The Zodiac Age takes the best game in the series and improves on it. But one thing about it that bugs me enough to write the upcoming diatribe is the way it handles loading and saving. It sounds petty, I know, but considering how often you’re likely to save in this game (and load, if you’re the perfectionist type), it’s a tiny annoyance that becomes quite significant with time.

In contrast to the original PS2 release, the remaster uses the PS4 system UI for all its load and save menus, so they’re inherently snappy and readable. These menus don’t gel with the in-game UI, so it’s a bit of an immersion breaker, but it’s not a major issue if the interactions within them are brief.

Let’s start by taking a look at how loading a game is implemented. When you start the game, you’re dumped into the title menu, which looks like this:

Choosing load game instantly brings up a list of saves, with the most recent one preselected. Neat! So far this looks pretty good!

But it only goes downhill from here. Choosing a file brings up the following prompt, asking you if you really want to load this save, with No preselected.

Select Yes and the file is loaded, after which you’re greeted with the following message.

Past this, you’re finally in the actual game part of the game. Alright.

Let’s say that while playing the game, you come across a save crystal and you decide to save your game manually. Now, the remaster does feature autosaving, but if you’re anything like me, you wouldn’t want to rely solely on autosaves for a long RPG like this. As you touch the crystal, you’re asked if you want to save.

This prompt was part of the original game and has been preserved in the remaster. Choosing Yes brings up a list of saves with the additional Create new file option preselected.

Both creating a new save and overwriting a previous one makes the game ask for confirmation, with No preselected, presumably to prevent accidental overwrites.

Choosing the Yes option performs the actual save operation, followed by a message confirming it.

Skip that and you’re back at… the list of saves.

You now need to press Back to exit the menu, and finally you’re free to proceed where you left off.

By now I hope you’re thinking the same thing I am. That’s a lot of unnecessary button presses for what should, ideally, be as quick and easy as possible. Let’s make some optimisations for these scenarios.

Drop the prompt after selecting a file to load

It’s only possible to load games from the main menu so there’s no chance of losing any progress by loading at the wrong time. Loading a save doesn’t modify it, and the load times are only a few seconds, so the benefit of this prompt is non-existent.

Drop the loading complete message

The player will generally know that their chosen save has been loaded when the game transitions from load menu to loading progress bar to in-game. Had the load times been much longer, this message might be used to prevent the player walking off during load and coming back to an unpaused game, but that’s really not the case here.

Don’t ask for confirmation when making new saves

It’s absolutely a good idea to prompt before making destructive operations like overwriting previous save files, but accidentally creating a new one is both non-destructive and easy to undo.

Drop the saving complete message

There’s a noticeable progress bar when saving which should hint that the operation is in progress, and silently transitioning from a progress bar to what the player was previously doing should imply that it completed successfully. This is perhaps more of a gray area than the loading complete message, but I still feel it could be dropped without much risk.

Close the entire menu after saving

Instead of reopening the list of saves, go back in-game to let the player continue. Going back to the list makes sense in a hierarchical UI system, but it doesn’t really fit the use case here. Interaction with the save menu is generally a one-off every time, so when the operation has completed, most players will have no further use for it but still have to manually close it. Assuming everything went well, the player’s priority after saving would be to either continue playing or quit the game, and the save menu assists with neither.

So there it is. We’ve fixed this tiny part of Final Fantasy XII: The Zodiac Age and made it much less annoying to use. It gets out of the player’s way and makes them spend as little time as possible in immersion-breaking system menus.

That other game

2019-02-12T00:00:00Z

Remember Crimson Wars? I sure do. But it’s not the only obscure game I remember from my childhood.

When I was in primary school I was really bad at math. I think my parents were worried I would never pick it up if they didn’t help it along, and so we had a couple of educational math games at our house. One of them was Gys på Regneslottet, released in 1996. It’s a math test disguised as a spooky castle adventure in which you open secret doorways by solving complicated puzzles such as 5 + ? = 6.

A few months ago, a friend and I somehow ended up talking about it as he also remembered playing it back in the late 90s. Google it, however, and you’ll find even less information about it than Crimson Wars. For the most part, it’s off hand comments in random, decade-old forum posts. Now, more than two decades after its release, I haven’t found anywhere to download or buy it, and the forum users promising to dig it out of their attics eventually fall silent. At first glance, it feels a lot like those “lost game” creepypastas that used to be popular; it just needs some tragic backstory to draw people in.

But of course, that feeling quickly subsides when you realize that two public libraries claim to stock a copy of it. When I looked, Gys på Regneslottet was currently out on loan, and I do wonder what kindred spirit got the idea to borrow this thing at the same time as me. Recently, their time was up and it got sent to me. What can I say, the system works.

As virtually no images of the game or its box exist online, I had hoped to scan whatever physical material came with this copy. Unfortunately, the front and back covers were sloppily cut out of the original box and placed in a soft plastic sleeve. The paper and plastic have fused together and it’s now impossible to remove the paper without tearing it. Bummer. You can find what’s left of it at the end of this post. No manual was included.

With a title like Gys på Regneslottet I had always assumed the game was some local Danish product, but it seems the game is in fact somewhat international. Gili Soft, who translated and published the Danish version, was a tiny company that operated between 1996 and 2002, but the game was apparently developed by a company called Compedia (probably these guys). I haven’t been able to determine the original title of the game, but it seems to exist in Turkey as Sevimli Hayalet. If you happen to know anything else about the game, do get in touch!

To conclude, here’s my rip of the disc. The game was made for Windows 9x and won’t run on any sort of modern PC, but here’s a hot tip: the virtual machine for Crimson Wars should work if you decrease the colors to 256. Good luck slaying the dragon!

What are hats?

2018-11-18T00:00:00Z

Well, it is quite simple. Let us take a look.

I was never really into Weebl’s Stuff. There are a couple of funny (or annoying, depending on your tastes) toons and tunes, but I never watched it on the regular back when it was hot shit a decade ago. But there’s one of his toons that stuck with me since, and thats Weebl and Bob episode 109: hat show.

It was animated by Weebl’s Stuff contributor Skoo and originally released on June 9, 2006. The other day, a friend of mine told me that he wanted to watch it again, but he couldn’t find it anywhere. It appears the official site has received a major makeover and many of the old toons are now gone. You can still find hat show and others in an archived snapshot, but that’s pretty difficult to find with regular googling. So I’m posting it here as a reminder and hope Weebl won’t mind too much.

Containerizing the infrastructure

2018-07-22T00:00:00Z

If you’ve been keeping an eye on my GitHub repos lately — and let’s be honest, who hasn’t — you might have noticed that several of my projects have acquired Dockerfiles.

The obvious reason is that I’m playing around with Docker, and since I’m the only known user of these projects I don’t really have to think about unsexy things like “compatibility” or “stability”, only insofar as “it works on my machine”. As is usually the case, I’m mostly doing this for the fun of it. Learning new tech improves my marketable skills, and if I like what I’m learning, I’ll happily spend my evenings on it. So far, I’m pleased to say that Docker is probably one of those cases.

It doesn’t hurt that Docker is now popular enough to be a bullet point in many job descriptions. In fact, that’s what made me give it a serious look. My current employer has some fairly “traditional” deployment procedures. Even though we run a number of different applications, the production environment consists of a handful of perpetually running Windows servers with important machine-wide configuration. So they won’t let me work with Docker on company time, but at some point I might just leave for a place that will. I then realized that regardless, I have a Docker use case all of my own. Allow me to pull back the curtain and tell you about my setup, and then rant a bit about my experience with Docker.

I barely get any visitors to my sites. I’m also kind of a cheapskate. For now, I run everything I need on a single $10 Ubuntu instance at Linode and, as of recently, serve it behind Cloudflare. Everything I need is currently this:

four static sites
two ASP.NET Core apps
a Node app with Express
a Python app with Falcon
a MariaDB instance
a MongoDB instance
a Let’s Encrypt client
an nginx reverse proxy

My ultimate goal is abstracting the server away enough that my entire collection of apps and sites becomes nothing more than a bunch of containers. It would open the doors to some new options, like being able to scale up to meet demand or migrating to a new server with barely any setup (the amount of setup is why my server is still on 16.04). I’m definitely not at that point yet, but I feel like I’ve taken a big first step in that direction. All but the last two in the list above are now running on Docker, and I find that pretty cool.

In my opinion, Docker is a difficult ecosystem to get into, and that’s mostly down to the tools you need to know to get anything productive out of it. Learning Docker on its own is fine but it won’t really cut it for any production deployments. For now I’m using docker-compose to manage my containers in production, but that in turn won’t cut it for more advanced things like scaling or automatic deployments. Then you might need something like Kubernetes or Docker Swarm, which is a whole new can of worms that I don’t have the energy to open. Yet.

Once you start using Docker, your deployment process changes. The process for one of my apps used to be:

Build the app in release mode
Upload the build output to the server
SSH into the server and restart the app

Very low-level and straightforward, right? Now, I’m deploying it like:

Build an image of the app using a Dockerfile I previously created (which builds the app in release mode)
Push the image to Docker Hub (for which you need an account)
SSH into the server, pull the image and restart the container using docker-compose

It’s only slightly more work, but it involves a bunch of extra concepts that don’t affect the app itself. What’s an image? What’s a container? What’s a Dockerfile, Docker Hub, docker-compose? Well, you’ll just have to RTFM. One site that helped me understand the basics is Docker curriculum, although it does leave out some important issues when it comes to more realistic app deployments. The official Docker documentation is pretty solid too, but it’s more of a reference than a gentle introduction.

For some things you can’t just RTFM though, and to me it was mainly how do I provide configuration files to containers? I obviously don’t want my production secrets in a public image, but I do need to provide them. It seems the official recommendation is using environment variables for configuration, but as nice and cross-platform as they are, they’re not really useful beyond simple key-value structures. Also, I don’t want to make too many changes to my apps in the name of containerization. If one day I decide that Docker isn’t for me, I want an easy out; I don’t want my app tightly coupled to its deployment mechanism. What I ended up doing for this particular problem was storing private configuration next to the app’s docker-compose configuration and bind mounting it into the right place. I find it to be a natural place to put it since my docker-compose configurations are also generally private.

Perhaps my favorite feature of Docker is the Dockerfile, which is a recipe for building an app as a Docker image. It’s basically a sequence of repeatable, easy-to-read instructions that can be distributed along with the source code. It makes the app’s system requirements very explicit and at the same time allows anyone to build it without having to deal with them. Imagine in five years from now you need to figure out what global packages your old app needs. Instead of reverse-engineering your old server or trial-and-erroring until it sort of works, you can just read your Dockerfile and be done with it.

My Docker transformation is still a work in progress, and the main thing missing right now is getting nginx running on it. I imagine it will be the most cumbersome conversion since my nginx setup has a bunch of configuration and brings all my sites down if it misbehaves. But if a tree falls in the forest and no one is around to hear it…

Marble Hornets returns, but not really

2018-01-24T00:00:00Z

A surprising turn of events for the guy(s) behind Marble Hornets.

If you’ve read my little writeup from 2016 on the group formerly known as THAC, you know that due to a rather sad series of events, it ended up consisting of only its founding member: Troy Wagner. Soon after, Troy rebranded as Fish With A Nose, and then again later as Grampo Co., which currently has just two bland animation shorts on its main YouTube channel.

After the mid-breakup Clear Lakes 44 project failed to gain traction, Troy cancelled it and launched a similar horror/mystery series called ECKVA, which is now Troy’s main focus. ECKVA has been received significantly better by the community, including a very positive review by Night Mind, but in terms of viewership it still falls short of the high bar set by Marble Hornets, currently receiving an average of just 25K views per video.

It’s now been three and a half years since Marble Hornets ended. On December 27, Troy tweeted this:

Smile for the camera pic.twitter.com/4rNi4OFo2w
— Troy Wagner (@whatatroy) December 27, 2017

In case you don’t recognize the mask, it basically means Marble Hornets will return in 2018. Very intriguing for sure, but how exactly will it make a return with only a single member of the cast and crew remaining? Troy stated in another tweet that the new project will not impact ECKVA, so how exactly will he pull off running two editing-heavy webseries at the same time?

Well, because according to his latest blog entry, it’s going to be a comic series. Huh. Okay. That was unexpected.

At this point it’s important to realize that key components to Marble Hornets’ success are impossible to translate to other formats. For my money, its strong points were the unique presentation and the frequent social media interactivity, which at times made it feel more like an ARG than a webseries. It was very much not the characters or dialogue, which unfortunately claimed more and more screen time as the show went on. I hope Troy is aware of this, and I really hope he’s not going to produce the comic by just drawing entries instead of filming them. It’s going to take some pretty off-beat creative elements to elevate it above a collection of vaguely recognizable Marble Hornets material with all the good bits lost in translation.

In related news, Tim is back! He originally teased a return in early 2016, but it would be another year and a half before he finally delivered a self-aware reboot of Space Time Express in December 2017:

He’s got a Patreon too, which seems kind of premature for someone with two uploads 16 months apart, but if it incentivizes him to continue making videos, I’m all for it. In my opionion, Tim is the most naturally funny member of what used to be THAC and probably has the best shot of any of them at producing quality comedy shorts.

It'll be our dirty little secret

2017-12-19T22:21:56Z

Here’s another update on what I’ve been doing lately, for the 1 person who follows my blog. Hi mom! Just kidding. My mom doesn’t read my blog.

Years ago, I joined a tiny IRC channel on a whim and ended up liking the people so much that I stayed there ever since, and I have even visited some of them in real life. At one point I made an IRC bot called nda specifically for the channel. IRC bots are the classic Baby’s first Python program, but for once it became a thing everyone actually liked (or at least tolerated). It did a bunch of things, but its best features were arguably !quote and !porn.

!quote was a system that would record every message in the channel and save it to a SQLite database. You could then query it using the !quote command, which would give you a random message from the entire collection. I wrote a simple script that would import years and years of chat logs acquired from one of the channel founders, so it ended up with a table of over a million messages to choose from. I initially ran nda on a Raspberry Pi under my desk, but the large quantity of quote data soon meant that I had to move it to the cloud to have any semblance of responsiveness. nda was single-threaded and blocked the event loop for the duration of the (quite expensive) database query.

Side note: the queries were expensive because the only way to get a random row from an arbitrary result set is doing ORDER BY RANDOM() LIMIT 1. There are a number of tricks to improve on this, and for nda, the best solution I came up with was:

perform a SELECT COUNT(*) of the matched rows as count
find a random number r in the range 0 ≤ r < count
perform the actual SELECT * using LIMIT 1 OFFSET r

This avoids ordering the entire result set at the cost of performing a count, which is pretty fast, and skipping through a number of rows, which is slower the larger r happens to be. My solution had decent performance for the use case, but in retrospect, this strategy would have been even faster had I thought of it.

The other feature, aptly named !porn, was pretty simple in comparison: you typed in !porn and it gave you a link to a random adult video and the longest user comment on that video. Okay, okay, I know how it sounds. But it’s a lot of fun. I don’t want to kinkshame anyone, but some people practically write entire novels in the comment section of porn sites – which I know exclusively from the professional research conducted in order to develop this feature – and it can be absolutely hilarious.

So, how would you go about finding a random video? For some sites, like Reddit or Imgur, it’s easy: you either have an API to help you out, or the URL pattern is simple enough to just brute force with random combinations until you find a link that works. But for the adult sites I investigated, they all used a much more complicated pattern, and porn APIs weren’t really a thing. For instance, Xhamster used a combination of the video title and a unique id in its URLs, which is impossible to crack by blindly hammering away at it. But the good thing about Xhamster: their randomizer button that just gave you a 302 to a random video.

Once you have a link, you can fetch the page and extract comments from it. The Python standard library has everything, including an HTML parser, and nda used this to parse the title and comments out of whatever video page was sent back. Thankfully, the layout stayed relatively stable and rarely broke the !porn feature. To remain inconspicuous, it spoofed the User-Agent header by using a couple of widely used identifiers, though in retrospect, they would probably just block the IP if it somehow became enough of a nuisance.

Over a year ago, the IRC channel became a WhatsApp group. A few people continued to use both, but WhatsApp was the only reliable way to reach everyone, and eventually we all abandoned the channel. nda stayed in the channel until all regular users had left, and was finally shut down for good last month. The channel registration has now expired. But I’m excited to say that the spirit of nda lives on in two spinoff projects based on its two best features!

!quote lives on in quote-importer, which expands upon nda’s quote database. It focuses on capturing and storing as much information as possible from chat logs instead of fast random access. It can currently parse Irssi logs, WhatsApp logs, and even nda’s logs, and saves several types of events; not just messages. It can then store them in various database systems like SQLite, MySQL, and MongoDB. I have recently used it to parse and import the entire catalog of our group’s IRC and WhatsApp logs into a single database, which currently clocks in at just about 3.4 million objects.

!porn lives on in talkdirty2me, which is a small .NET Core/Vue web app (live demo here, turn up the volume). It works much like the original feature did: it gets you a random video and its longest comment. It also saves the comment and generates a shareable permalink that works nicely in rich previews. Xhamster remains a valuable source of quality comments, but there’s an important technical update: Xhamster now has a REST API! I know!! It’s undocumented and not particularly pretty, but a recent update to their site uses it to – you guessed it – fetch comments. You no longer have to parse HTML to get the comments for a video. If you have the video’s id (which can be extracted from the URL) and a few secret headers up your sleeve, you can get its comments in a paged JSON list, which is a huge upgrade from trying to match element ids and CSS classes. I haven’t yet found an endpoint that gives me the video title, so for now, a small amount of HTML fiddling is done with a regular expression.

So that’s what I’ve been up to recently. As I mentioned before, I’ve also rewritten crimsonwars.net as a static Jekyll site. Even though it’s technically simple, I’m still proud of it and want to make it public on Github. I just need to separate the somewhat questionable downloads from the rest of the site so they don’t endanger my account. More on that later, maybe!

Headless wifi for the Pi

2017-11-29T22:00:57Z

I was setting up a headless Raspberry Pi today and was happy to find that you can preload wifi settings onto it, removing the need for any physical interaction with the thing. But there’s a trick to it.

Ideally, you should just be able to add a wpa_supplicant.conf file with your network settings to the boot partition, and the Pi will move it into /etc/wpa_supplicant/ for you on boot and have Raspbian automatically connect with those settings.

Some of the most popular answers for this topic provide you with a wpa_supplicant.conf example that contains nothing but the network block. Unfortunately, those examples aren’t quite complete for practical usage. As it turns out, there are a couple of magic words that make the difference between having a networked, headless machine and a brick with lights on it. As of November 2017, you need something like this:

country=GB
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1

network={
    ssid="Your wifi name"
    psk="Your wifi password"
    key_mgmt=WPA-PSK
}

Those first three lines were taken from the default wpa_supplicant.conf found on a fresh image of Raspbian. In my situation, it seems that the country line is not actually needed, though your mileage may vary.

And despite what some people out there on the web may claim, placing the file on the boot partition does work as intended with Raspbian Lite. Remember to also add an ssh file so you can actually mess with it once it’s online!

CrimsonWars.net is up

2017-10-02T17:26:54Z

I love my little side projects, but they always end up being some sort of interactive app. I want to make more regular websites, but what can I possibly make that hasn’t already been made a thousand times before?

Well, there’s an old game I remember from my childhood. It’s called Crimson Wars, a game that’s probably not very good, but still sparks nostalgic feelings whenever I remember that it exists. The thing is, information about it online is close to non-existent. There are some gameplay videos and some game disc rips, but that’s pretty much it. No wiki, no guides, no lore.

So now I have created crimsonwars.net, the one stop shop for all your Crimson Wars needs! I imagine very few people are interested in it, but the domain was cheap and I had fun making it.

It’s made with ASP.NET Core 2 and Razor pages, which is something I’ve been wanting to try out but haven’t had a good use case for. At first I was concerned that it would require copious amounts of boilerplate and high ceremony, but I was pleasantly surprised how easy working with it turned out to be. Razor pages seem to be extremely well suited for making mostly static content where you still want some form of reusability and customization. It basically allows you to write only .cshtml files and transparently handles controller actions and routing for you.

Anyway, this was just a quick note about what I’ve been working on lately. I hope to be doing more content-focused websites like this in the future.

Update 2017-12-11: In the interest of simplification and trying out new things, I have rewritten the thing as a completely static site – which it kind of was anyway – using Jekyll and a lot of Markdown.

PIA on a Pi

2017-06-26T15:35:53Z

Here’s a short guide to setting up a VPN on Linux — specifically Private Internet Access on a Raspberry Pi, because I’m mostly writing this as a reminder to myself — with a kill switch to prevent non-VPN traffic. I’m targeting a Pi 3 with Raspbian Jessie here, but the procedure should be similar for other machines and distros as long as packages like OpenVPN and UFW are available.

OpenVPN setup

Install OpenVPN.

# apt-get install openvpn

Download the VPN provider’s OpenVPN configuration files. For PIA, this usually means this one.

$ curl -O https://www.privateinternetaccess.com/openvpn/openvpn.zip
$ unzip -d openvpn openvpn.zip

OpenVPN on Linux uses .conf for config files instead of .ovpn, so rename them accordingly.

$ rename 's/ovpn/conf/' openvpn/*.ovpn

To enable automatic authentication when connecting, put your VPN username and password in a file next to the configs.

$ echo 'CoolGuy123
s3cr3t' > openvpn/auth.txt

It’s not very secure, so add a little protection by limiting access to the owner.

$ chmod 600 openvpn/auth.txt

Next, make the configurations refer to this file by appending some directives at the end of each. Here I’ll also throw in a couple of quality tweaks such as keepalive, logging to make troubleshooting easier, and automatic execution of a script called update-resolv-conf, which might be necessary for DNS resolution to work correctly when turning the VPN on and off. On Debian, this script is included in the OpenVPN install.

$ echo 'auth-user-pass auth.txt
keepalive 10 60
log-append /var/log/openvpn.log
script-security 2
up /etc/openvpn/update-resolv-conf
down /etc/openvpn/update-resolv-conf' | tee -a openvpn/*.conf

From here, it might make sense to continue as root. Move everything into place by copying the auth file, configurations, certificate and key file to /etc/openvpn.

# cp openvpn/* /etc/openvpn

To make OpenVPN automatically connect with a certain configuration, set the AUTOSTART directive in /etc/default/openvpn to the configuration filename without the extension.

# echo 'AUTOSTART="Germany"' >> /etc/default/openvpn

Note 2020-03-14: since this post was first published, there’s a better way to run OpenVPN as a service. Instead of using /etc/default/openvpn, move all the configuration files one level down into /etc/openvpn/client and enable the service by calling systemctl enable openvpn-client@Germany. I’ve tested this on Raspbian Buster, but I’m unsure if it works on older versions as well.

It should now be possible to start up OpenVPN and have it connect.

# systemctl daemon-reload
# systemctl restart openvpn

To verify this, wait a few seconds and run ifconfig. There should be an interface called tun0 or similar (for tunnel), which is the VPN interface. To test connectivity, call an IP echo service such as ipinfo.io, which should report an IP and a country matching your configuration.

$ curl ipinfo.io

UFW kill switch

At this point, if the VPN connection drops or OpenVPN stops for some reason, your machine will talk freely over your regular, non-VPN interface. Depending on the use case, it might be preferable for it to stop communicating completely instead, like if you’re ~~downloading warez~~ concerned about your privacy.

To ensure this, we’re going to set up a firewall to deny everything but the VPN handshake on the regular interfaces eth0 and wlan0 while placing no restrictions on tun0. I’m going to use UFW because it’s fairly intuitive compared to iptables.

# apt-get install ufw

Next we fill in the firewall rules. First, allow everything on OpenVPN’s network interface.

# ufw allow in on tun0
# ufw allow out on tun0

OpenVPN obviously needs to be able to connect on the regular interface, and with the default PIA configuration files, this means allowing

DNS resolution on port 53 to find e.g. germany.privateinternetaccess.com
The actual VPN port specified by the configuration files, i.e. 1198

# ufw allow out on eth0 from any to any port 53
# ufw allow out on wlan0 from any to any port 53
# ufw allow out on eth0 from any to any port 1198
# ufw allow out on wlan0 from any to any port 1198

You might also want to have the machine reachable from the local network to SSH into it and such, so allow everything to those IPs. My local network has IPs in the 192.168.0.* range so I’ll be using that.

# ufw allow in on eth0 from 192.168.0.0/24 to any
# ufw allow in on wlan0 from 192.168.0.0/24 to any
# ufw allow out on eth0 from any to 192.168.0.0/24
# ufw allow out on wlan0 from any to 192.168.0.0/24

Finally, block everything else and enable the firewall.

# ufw deny in on eth0
# ufw deny in on wlan0
# ufw deny out on eth0
# ufw deny out on wlan0
# ufw enable

Now test this by stopping OpenVPN and sending a request:

# systemctl stop openvpn
# curl --connect-timeout 5 ipinfo.io

Because DNS is allowed outside the VPN, ipinfo.io is resolved, but the request times out after 5 seconds because port 80 is blocked. Turning OpenVPN on again restores connectivity.

And that’s basically it. Easy, right? Not really, but it works fairly well.

Sometimes, the internet does forget

2017-01-31T16:20:00Z

Remember that old adage that goes something like, once you put it on the internet, it will be there forever? Well, sometimes it won’t. And then at some point, maybe it will. Wait, what?

Back in 8th grade (which would be 2006 or so), I stumbled upon a series of crudely made internet videos by a guy named David Baker. David, who I assume was in his mid to late teens at the time, had made 11 short episodes of a cartoon about Super Go Up Stairs Man, a spoof anime superhero whose super power was the ability to go up (and fall down) stairs. The episodes ranged from basic plots to complete nonsense, but usually centered on the titular character and his arch nemesis the Jeep (who was supposedly evil). From the looks of it, it was made entirely with Microsoft Paint, Windows Movie Maker, and stock photos from Google image search. As low-budget (but not necessarily low-effort) as it gets.

In addition to the videos, which were hosted on Google Video (remember that?), SGUSM had an official webpage on one of the free web hosts that were popular back then, like Angelfire or Freewebs (remember those?). Even for 2006, it looked terrible. Its primary colors were pink and black, it had Javascript snowflakes falling down the page, and I’m pretty sure it also played a MIDI. Whether or not all this was intentionally bad is anyone’s guess — I would say yes — but it sure was quite a sight.

Myself and a couple of my classmates found SGUSM hilarious and lines from the show quickly became little inside jokes. That was a decade ago, and I hardly talk to any of them these days. But every once in a while I feel like taking a trip down memory lane. Imagine my surprise when today, the Google results looked like this:

Apart from random strings of characters, this might be the emptiest search page I’ve ever seen. And no, the one result is nothing more than a highly outdated list of Google Video links. Were we the only people actually watching SGUSM back then? I have no view counts to refer to, so who knows. In any case, the videos seem to be gone from the surface of the web. As a person who cares way too much about preserving old data, this makes me very sad.

But then I remembered: at some point, I saved all the episodes to my computer. Even though my computer from 2006 is long gone, much of the data from that time has been archived on several generations of external hard drives. So here I’ll post what I believe to be the entire series, and the internet recalls one very insignificant memory. I’m obviously doing this without permission from the creator. David, if by any chance you’re reading this far off in the future, be sure to drop me a line. Update 2017-05-23: now with permission. Thanks Dave!

Super Go Up Stairs Man Series 1

Episode 1: Hard street being in sometime

Episode 2: If Heerotishimi desert bin gen then fire breathe from Dragon nextime

Episode 3: No Evil

Episode 4: Map E

Episode 5: Jeep

Episode 6: The Credit Pirates

Episode 7 (Japanese TV show)

Episode 8 (Lift)

Super Go Up Stairs Man Series 2

Trailer

Episode 1: The People Talking Are The Superhero Council

Episode 2: NEWS

Episode 3: Is It Snowy, Sure!

Simplification is a good thing

2016-12-18T10:47:00Z

Although PHP is (with good reason) regarded as a bad language, it holds a special place in my heart. It was the first useful programming language I learned when I started getting into coding in my teens, and since then I have used it for everything from simple dynamic pages to large ORM-powered APIs. The former is definitely the problem that PHP solves best, as there is practically no setup or boilerplate required to get a page up and running (if you discount the HTTP server). It’s a technology that is in my experience still unmatched on ease of use for that purpose. Sadly, the web of 2016 has little use for such simple things, and over the years PHP has borrowed so many concepts from other languages that modern PHP has mostly ended up a slightly worse version of them. It has classes, but little type safety. It has collection libraries, but no generics. It has lambdas, but no terse syntax for them. And yet, because of its ubiquity, it’s still widely used for relatively complex systems around the web.

My personal web projects were historically PHP-based because I grew up on free web hosts that allowed PHP, MySQL, and nothing else. But for the last 18 months this site has been running on a $10 Digital Ocean droplet that hosts everything I need, from Ghost to nda to a custom personal finance tool and more. Over time, I retired or replaced most of the stuff that used PHP; not because I specifically wanted to get rid of it, but as a natural consequence of changing interests. But until today, there was one application of mine still relying on a LAMP stack to function, and that’s my game collection app that I sort of mentioned almost two years ago.

This irked me a bit. The only reason I kept Apache on my server was to support this single thing. nginx is on proxy duty anyway, so static files could be served just as well by that. And making a significant change to the underlying technology is one of the freedoms you are afforded when no one but you depends on the project. So for the last month, I’ve been porting the entire backend to something else: ASP.NET Core with Entity Framework Core. C# is a good language and I’m very happy to see that Microsoft is committed to making .NET (and important frameworks) cross-platform. I also haven’t used .NET extensively in a web context before, so it’s been a great learning experience.

The rewrite also made me realize that some architectural decisions didn’t make sense anymore. The old list evolved from a simple mysql_query() call on a shared web host where MySQL was the only option, but of course, that’s no longer a requirement (and realistically hasn’t been since it started using tools like Composer and npm). Relying on MySQL also comes with its own issues, namely having to install and run mysqld if you aren’t already. So while we’re at it, we might as well replace MySQL with something more suited for the task. I can think of no better option than SQLite: it’s zero-configuration, it’s easy to manage, and it has first-class support in EF Core. Using SQLite not only simplifies the system requirements for the application, it also simplifies configuration: Previously, you would have to enter a database address, name, credentials, and a table prefix in addition to app-specific options. With SQLite, everything but the last one can be skipped because it’s self-contained and uses no access control mechanism beside the filesystem itself.

Another (unrelated) simplification I implemented in this version was replacing Gulp with npm as the frontend build tool. Gulp seems like a good tool if you’re doing large, multi-target build tasks, but in the case of g_, the only task I need is concatenating and minifying Javascript files. I recently read an interesting article on how to use npm itself as a build tool, and since npm is a dependency anyway, we might as well make use of it. Previously, the build task was carried out by a 30-line gulpfile.js and required Gulp, two plugins, and the tools that actually provided the functionality. With npm, this was reduced to a dependency on UglifyJS and a one-line command in package.json. If we wanted to add a file watcher that would be one more dependency and one more command. Easy.

The new, rewritten version is actually live right now. Nothing at all should change from the looks of it, but everything behind the scenes has been ripped out and replaced with new, shiny, (relatively) typesafe code. This is a testament to how well a single-page app with a REST API separates frontend and backend concerns: not one line of client-side Javascript has been changed as a result of this rewrite.

So with this, it looks like I can finally retire Apache (and maybe even MySQL), and I have learned a bunch about the .NET Core stack at the same time. I’m gonna go ahead and say that’s a win-win.

A quick note about PIA port forwarding

2016-10-20T17:06:01Z

I use the Private Internet Access VPN provider, which allows you to request forwarding of a single port from the public IP to your machine. It’s a cool feature that technically allows you to run any kind of server application through an anonymized connection, though its primary use case is obviously to make your torrent client directly connectable.

But I just couldn’t get it to work. The PIA client claimed to have a port forward set up, but no traffic came through when testing it; any request I made just timed out. I exchanged about 15 emails with their support team, who gave no helpful answers to my questions and repeatedly sent me their µTorrent guide, screaming THIS FEATURE IS FOR TORRENTING ONLY AND WE DON’T KNOW ANYTHING ABOUT LISTENING SOCKETS. But after a while I found a quirk that is apparently documented nowhere:

If you run your server and client application from the same machine, port forwarding won’t work.

It turns out the feature had (probably) been working all along, but I was testing it by listening and issuing requests from the same machine, through the VPN, to its own public IP. As soon as I used another machine as the client, everything worked as it should.

I don’t know if this is just an issue with my network, a bug in PIA or my own stupidity acting up, but it’s an entirely non-obvious detail that I currently can’t explain. For good measure, I asked PIA support if this was a known limitation and they responded with this:

Port forwarding is only used in torrenting to speed up slower downloads. Any use of port forwarding outside of that is not supported nor recommended.

Yeah, thanks.

The rise and fall of a minor YouTube group

2016-06-18T22:56:14Z

If you’ve got even a passing interest in obscure internet drama, here’s a story for you. Early last month, THAC TV, the group behind the kind of popular YouTube series Marble Hornets disbanded after a series of unfortunate events during the past year or so. Let me tell you a bit about it from my perspective as nothing more than a fan. Well, at least I used to be.

Marble Hornets

The story begins almost seven years ago. In June 2009, the Marble Hornets channel uploaded the first two videos of what would become THAC’s most successful work to date and probably — with what happened recently — of all time. The series was a fictional, found footage style horror/mystery show focusing on the internet-created character Slender Man. Originally, the series was mainly produced by two twenty-something friends, Troy Wagner and Joseph DeLage, with Troy playing the protagonist Jay and Joseph playing the (eventual) antagonist Alex. During the first season of the show, other characters were introduced, and the character of Alex’ friend Tim, played by Tim Sutton, became a mainstay and much later a fellow protagonist. Marble Hornets had a number of twists and turns in the course of its three seasons and 87 main episodes, which lasted from June 20, 2009 to June 20, 2014. In addition to the main episodes, it included a companion channel and a Twitter account to make it somewhat ARG-like. It was very exciting at the time, but one thing is for certain: it all went downhill from the beginning.

Regardless of how you feel about the individual seasons, there’s no denying that the first one is the most popular, and depending on whether or not you agree with me, it’s also the best. Marble Hornets grew from a sequence of short and unsettling clips with little context to a genuine story with characters, dialogue and drama. And these things tend to work better if they’re not written, directed and acted out by amateurs. This is by no means a dig at Troy, Joseph and Tim. No one expects world class writing and acting from a free YouTube series, but the original format was definitely better at working around these limitations, to the show’s advantage.

At the time of writing, nearly every season 1 episode has gained over a million views, and the first few have several. Season 2 episodes hover between half a million and a million, and season 3 a few hundred thousand less.

As a side project to Marble Hornets, the three main creative forces behind it occasionally made surreal comedy videos for Troy’s personal YouTube channel, Troy Has A Camera. Some of these went on to be mildly successful, no doubt fueled primarily by fans of their horror series. In December 2013, during the third and final season of Marble Hornets, the group registered a company, THAC LLC, mainly for the purpose of merchandise, including a successful Kickstarter for the season 3 DVD.

A new direction

When Marble Hornets ended for good in 2014, the group shifted their focus to comedy videos for the THAC channel, which was now their primary output. As part of this, they brought in a fourth member called Noah Scammon. I was skeptical of him at the time. With their videos and behind-the-scenes info, the three original members had built up a relationship with the fanbase. Noah hadn’t and yet became a prominent part of the face of THAC; it was like he was forced onto us. But the addition of Noah wasn’t the only noticeable change. Around this time, a pattern was emerging: give each member of the group their own recurring comedic character and show. The roster eventually turned into:

Nature Break with Craig Digsby (Troy), a nature show
Space Time Express with Morningstar Sinclair (Tim), a space show
Fixin’ a Fixit with Owen Hankinson (Joseph), a DIY show
Spooky Drawer with Dominic Darkwalter (Noah), a spooky story show
Cyber Tricks with Computer Jym (Noah), a computer show
Isn’t That Something with Dr. Thompson Hacke (Troy), a science show

In addition to these formats, THAC was now also producing a variety of out-of-character videos like Let’s Plays, a podcast, and DnD campaigns. Although they would still occasionally make the kind of original shorts they started out with, it was no longer their main concern. Still, at the time, I was optimistic. Noah started to feel like an integrated part of the team, and the regular formats were occasionally entertaining. Things could definitely have been worse, and I was still somewhat invested. But as we’ll see, most of the shows would end up shortlived.

On August 3, 2015, new videos started appearing on the Marble Hornets channel, titled Clear Lakes 44 (which have recently been unlisted). This was to be a successor to Marble Hornets — direct or spiritual — having been teased as the final stretch goal on the season 3 DVD Kickstarter. Clear Lakes 44 started out with fast updates and decent popularity, but just like with Marble Hornets, interest was steadily dropping.

Halving the team

Some time in October of 2015, Joseph and Tim left the group. At the time, the circumstances of the breakup were kept vague by all of the people involved. No one knew exactly how nasty the split had been. Maybe it was creative differences. Maybe it was gigantic creative differences. I think it’s fair to say that the fan community was unsure how to deal with it: Troy was the founder and initial force that put THAC on the map, but Joseph and Tim had been essential parts of everything good they had ever made. Soon, Troy wrote a post just a few buzzwords short of being a corporate press release.

THAC is absolutely not a studio that has any interest to scale back or drop off content. In fact, moving forward from here, and into 2016, the company lives strong and will be releasing even more videos and series as planned.

According to Troy, the workforce of THAC was effectively halved, yet the workload would actually increase. A bold promise that didn’t exactly build confidence, especially from a post where the group’s usual transparency and honesty was nowhere to be found. Regardless, life — and THAC’s remaining video series — went on.

While Clear Lakes 44 was indeed still in production under Troy and Noah, things weren’t looking too good for it. The release schedule slowed to a crawl, fans generally found it to be too slow and confusing, and view counts were consistently lower than even the worst MH episode. The most recent CL44 episode to date, Broadcast #13, was released on February 18 and has just over 39,000 views to date. I’m not exactly sure when, but somewhere along the way I stopped watching. In my opinion, Clear Lakes 44 was just too cryptic for its own good. A slow burn can be great, but as it turns out, running a web series without any significant events in its first six months may not be ideal. At the same time, THAC’s comedy videos became less and less entertaining, culminating with a bunch of mediocre Let’s Plays and this cringe material.

Back to square one

The story ends in April of this year, where Troy spills the beans about the split with Joseph and Tim. There’s no reason for me to go into it as his account of things is very detailed and has been verified by Joseph and Tim. What I will say is this: what shred of optimism I had left for THAC is now dead and gone. I had always assumed the breakup was just a matter of creative differences, but it was much more complicated than that; things were apparently bad enough that they didn’t speak to each other for five months. Later in the thread, Noah posts a long sentimental post about his memories of the other guys, and then Joseph answers with just this:

Dude, eat shit. Eat shit and be glad that I still (mostly) maintain a sense of professionalism about this whole thing.

At first Noah’s post seems like an attempt to douse the fire, but the jarring difference between its sugar-sweet tone and Joseph’s aggressive response definitely raises a red flag. Was Noah secretly mocking him? Does Joseph hold Noah responsible for splitting the group? Is Noah just unreasonably optimistic about the whole thing? We’ll probably never know, but it’s obvious that the two aren’t exactly on good terms.

Two days later, after a lot of reactions, discussions and (ugh) memes, Troy posts another update on how he has asked Noah to leave THAC, effectively cancelling all shows he was involved in, including Clear Lakes 44. This puts THAC back to how it was seven years go: just Troy and a camera. You might think hey, that worked out pretty well last time! And you’d be right. Except last time, things only got really good with the help of Joseph and Tim. Troy might be able to find other partners, sure, but there’s another problem. Last time — and this is purely speculative — it was a hobby fuelled by the passion for creating stuff. This time, it needs to make money: Troy has a young daughter he needs to support financially, and presumably has too little spare time to make THAC a hobby project.

My best guess: THAC, and the things it used to make, are dead. According to Troy, he’s got plans to reboot CL44 (hence the unlisting of existing episodes), but I’m not going to get my hopes up. As for the rest of the crew: Tim made a decent video in February, promising more videos the following month (which have yet to surface). Joseph works at a deli and has no current plans to make more YouTube stuff. Noah is working as a production manager and generally has an active online presence, though he hasn’t produced any significant solo content lately.

But let’s not end this on doom and gloom. Although I think the chances of anything worthwhile coming out of this debacle are slim at best, who knows? Maybe there will be a Clear Lakes 44 v2.0, and maybe it will be fantastic. Maybe each former member will make great videos on their own, and maybe they’ll eventually reconcile. Let’s just hope and wait.

Update: Troy has rebranded his new solo outfit as Fish With A Nose, which currently has no uploads and is not included in the first page of a Google search for “fish with a nose”. Best of luck to Troy!

Update 2: The THAC forums have been discontinued, so I have updated the links to archived versions of the posts.

The many themes of Undertale

2015-11-01T21:47:06Z

If it wasn’t already obvious from its 94 metascore, Undertale is a pretty good game. Not that I was easy to persuade into buying it. Visually, it looks absolutely horrendous. But that’s part of its charm, you say. Absolutely, but not to the uninitiated random person scrolling through new releases on Steam. It’s good to see it’s getting recognition left and right, though everyone agrees that the less you know about it beforehand the better. Go buy an indie game that looks like it belongs on the GameBoy Color without looking up what it’s about? That’s a pretty risky proposition if you ask me.

As of a few days ago, I’ve done a neutral run and a pacifist run. They were emotional rollercoasters and yeah yeah we all know what’s up. And now I can’t show the game to anyone or start another run because doing a true reset would break my heart after hearing the begging and knowing about the persistence tricks it pulls on you. The game is a rare example of how well meta can be done: it’s funny, it’s clever, and it’s essential to the story.

The soundtrack is stylistically all over the place with 8-bit, 16-bit and 32-bit instrumentation mixed together, but totally amazing all the same. I don’t think there’s a single decidedly bad song on it, which is an impressive feat for a hundred tracks. What’s fun to notice while listening to it is how certain themes are reused in creative ways throughout the entire album. And so I decided to visualize it.

In this directed graph (dot, svg) of the 101 tracks on the official soundtrack, each edge is a relation between tracks such that samples of the track with the outgoing edge are being reused or remixed in the track with the incoming edge. When determining which track should be the source and which should be the sink, the album ordering is used: the earlier the track appears on the official tracklist, the more “original” it is considered.

I created this purely by listening to the entire soundtrack and picking up on similarities, so while the majority is covered, I probably missed some connections here and there.

Edges that I deemed redundant have been removed. A good example of this is the relationship between Once Upon a Time, Start Menu and Menu (Full). The third is mostly a re-instrumentation of the second, which in turn owes its melody to the first. In my original graph, there was an additional edge between the first and third, but this (and others like it) have been removed to make things easier to read.

The most obvious recurring theme is Once Upon a Time. It’s the first theme you hear when starting the game, and it’s used throughout the entire game right up until the end. Bring It In, Guys! is a credits medley of various themes, which is why it has a lot of incoming edges.

I have no deeper analysis to go along with the graph. Just have a listen to the soundtrack and pick out the moments where the themes merge and evolve :)

It's April again...

2015-04-08T14:12:40Z

… and my cake gains another candle.

I can’t believe how some people come up with material for daily or even just weekly blog posts, god damn. Since my last awkward attempt at updating this thing, I have resigned from my (now previous) job and started another, and on top of that I’ve become involved in a side project that’s very ambitious for two guys to be developing in their spare time. In addition to my education of course, which my parents keep reminding me not to neglect. Don’t worry, mom and dad, I won’t. Too badly.

Gaming-wise, it’s actually been a slow year so far. Just for curiosity’s sake, I’ve got a text file where I try to place as many games as I can onto a when-did-I-play-this timeline (which I might integrate into my collection app at some point). Maybe it’s just because remembering what discs I was putting into my PlayStation a decade ago is hard, but there’s a pretty clear trend going on:

You know, I feel slightly embarrassed. Being a half-casual gamer is a dubious claim when you finish 50 games in a year; that’s roughly one each week. And it’s not even socially acceptable games like FIFA or Halo where playing the game doesn’t automatically place a giant L on your forehead in the eyes of society. It’s more like BioShock and Skyrim. “I just play it to pass the time.” Yeah right.

If only the internet didn’t exist so I could be blissfully unaware of new releases and not just rush through everything. With the internet gone, maybe I’d even gain some social skills and meet new people. Oh well, a guy can dream. Or have nightmares. It’s both, really.

But it looks like 2015 is bucking the trend. So far I’ve played three games to the credits: Far Cry 4, Alien: Isolation and Wolfenstein: The New Order, and I’m currently a few cases into L.A. Noire. That’s more like one a month.

It’s alright. As I said there are plenty of things to do and so gaming time is deprioritized, as it should, and I consciously try to avoid turning a fun hobby into a chore by rushing things.

Of course, I’ll have to play GTA V when the PC version comes out in a week, and I’ve also been hearing a lot of praise for Pillars of Eternity, which several of my friends are playing. Maybe I can finally get into something that can’t be played with a controller. Maybe I’ll also suddenly become a cool dude and accomplish something with my life.

Yeah right.

Long time no write

2015-01-31T11:07:36Z

My my, how time flies. It’s been a busy couple of months since my last post with school and work running at high capacity. There has still been time to play some games, but nothing I really want to talk about, so here’s a one-sentence summary of each:

Alice: Madness Returns: I haven’t seen quadruple jumps since … actually I don’t remember ever seeing quadruple jumps before.
Oddworld: Stranger’s Wrath: A pretty cool twist.
Torchlight 2: Fooled ya! That’s not the final boss!
Shadow Warrior: 17 chapters with enough ideas for maybe 8.
Darksiders 2: Look boss I made the level huge so there’s room for all the players … wait what do you mean it’s not an MMO?
Viscera Cleanup Detail: Whoops you brushed the bucket against my arm and now I’m dead.

Now that’s taken care of, here are some other things. I want to say “things not about video games” but of course it fucking is.

For one of my school projects, we created Monospace Hero, which is part game, part level building tool and allows you to write your own platforming levels using only a text editor. Basically, you’re a symbol jumping around on other symbols. Check this page for more details.

For a few years I’ve been using my own web based video game collection app to keep track of my growing collection across several platforms and services. I still feel that things like Playfire, while great in many aspects, do not give me enough control over my data, which is really the most important feature to me. So for the time being I’m relying on my own custom solution.

A year ago, the app was just a for-each loop in PHP spitting out all the rows in a database table. Today, that’s still a part of it, but the entire thing has been rewritten as an AngularJS application using a JSON API and Bootstrap. It provides advanced filtering, high customizability, statistics, and a whole bunch of other features. I even wrote an installer that makes it about as easy to install as WordPress! I now call it g_. I’m still working on getting it a nice description page (and probably publishing the source somewhere), but for now, my actual live version that I use can be found right here.

I completed a hard game for once

2014-11-20T21:06:47Z

Being kind of a quitter, I’m very easy to dissuade from pretty much anything and I find comfort in the fact that if life gets too hard, there’s always an easy way out called suicide. So while I’m waiting for that to inevitably happen, hard games and I have an agreement. I don’t play them, and in return they don’t make me feel like an idiot. Sometimes though, like a zoogoer jumping the fence to the lion den, I break the rules and get mauled and eaten. Figuratively speaking. Almost.

High difficulty is why I never finished Super Meat Boy. It’s why I only finished XCOM: Enemy Unknown through save scumming, and it’s why I’m surprised I managed to finish Dark Souls. Originally I was going to use this post to complain how the game was basically unplayable, but then something happened and I was actually enjoying it.

Also, this fucking thing

At first, I went in blind with a melee class and got stuck in Undead Burg. Then, I started a cleric game, cheated every stat to 99 and still died at the bridge to Undead Parish. It drove me half mad. As I previously mentioned, I have trouble keeping interested in games nowadays, and an unusually high difficulty certainly doesn’t help. I hate leaving a game half finished — it should preferably be either finished or left alone from the start — but playing the same thing over and over without progressing is even worse, and that’s exactly what Dark Souls was making me do. Oh, but it’s alright, you see, you’re supposed to play it for it’s difficulty, which is a bit like saying you should visit Africa for the ebola.

I had just about had it with the game when I found the Dark Souls easy mode walkthrough by some guy calling himself the Tech Phantom. Despite the name and the intro (it gets old), his walkthrough is very in-depth and for the most part noob-friendly. The reason for making it, he says, is to demonstrate that an easier difficulty setting for Dark Souls is unnecessary, but that doesn’t really work when the entire thing hinges on taking very specific routes to get very specific items, i.e. things you’d need expert-level knowledge of the game to know is even there. And new players aren’t going to have expert-level knowledge, they’re going to flail their starting mace around and hope that whatever’s in front of them ends up dying before they do (it won’t).

I shouldn’t be too hard on the guy, though. While I would have loved to say that I completed the game through perseverance and carefully honed skills, the truth is that I have one person to thank for it, and that’s the… “Tech Phantom.”

Now that I actually finished it, I find it hard to formulate a concise opinion about it. It’s an immensely obtuse game that starts out with saying “ring two bells, one in a church and one underground, GL HF ;)” and you’re basically left to figure out for yourself which way will get you killed by a gang of skeletons and which way will get you killed by a gang of ghosts, which can be really jarring if you’re coming from any game with objective markers and extensive tutorials. I’d say this approach lends itself very well to exploration, which it does, but the consequences of going the wrong way are grave enough that exploration is only fun when you have learnt to play the game well.

All in all though, it sucked me in as soon as I was able to make steady progress, and it kept me interested for a lot longer than many other games have. The open world design is probably it’s strongest point — everything is connected in ways that’ll make you go oooh! — but there’s just so much shit you have to go through to appreciate it, and that makes it a hard sell.

Heh. Hard. Get it?

Golden Suns

2014-09-17T14:09:56Z

I never really cared much for handheld gaming. My commutes have rarely been long enough to justify gaming sessions, and if I’m at home I’d much rather enjoy something with a proper controller and a large screen.

I do have a soft spot for personal recommendations though, and in this case, a friend of mine recommended Golden Sun to me: an FF-esque turn-based RPG for the Game Boy Advance. I’ve never owned a Nintendo machine in my life, but thanks to the wonders of emulation it is now possible to play this thing on any decent smartphone. Yeah, using Visual Boy Advance on your PC is totally a thing but for obvious reasons it doesn’t really capture the feel of handhelds (notably eyestrain and finger cramps). While emulation is never completely authentic, My Boy! works really well for the most part, enough so that I left a 5 star review of it on the Play Store. I wouldn’t want to play Super Mario on it though, I’ll tell you that.

Anyway, Golden Sun. My friend repeatedly tells me how great these games are, and while I initially fought his rose-tinted glasses with huge grains of salt, it turns out he’s kind of right. At first glance, it seems like a totally generic JRPG. It has random encounters, an inventory system, turn-based battles that take place in an alternate reality, and protagonists who look about twelve. Where it begins to veer off familiar turf is when it introduces its djinn system, a twist on summons. Basically, each djinni (summon) can be either “set” on a party member to boost their stats, or unset, at which point the djinni will use its unique ability. It can then be used as a simple elemental summon attack or be combined with other unset djinn to form stronger summons.

Sometimes, my strategy fails

It’s a pretty neat system. Do you keep each djinni set to boost your stats or do you need something provided by their abilities? Do you summon them right away to regain your stat boost or do you unset all your djinn for a stronger summon? How much of your stat boost can you afford to swap for greater summon damage? There’s a lot of room to experiment and strategize. You know, if you don’t just spam Attack over and over like I do.

Another cool feature: you know how in most JRPGs your spells don’t do shit outside battles? In Golden Sun, every dungeon and town has some environment puzzles that can only be solved using specific spells, like moving a pillar out of the way, freezing a puddle of water into a platform, or growing a plant into a climbable vine. It’s not just some gimmick either; it’s used so often that it becomes a central game element, and it works well. Sadly, it’s not always as intuitive as you’d want. In the sequel, The Lost Age, you get several spells for overcoming rock obstacles — burst, grind, and lift — that are very similar but only work on their respective kind of rock, which the game just assumes you’re cool with. The obvious reason is gating players until they reach a certain point in the story, but it seems to me they could have easily used other obstacles with somewhat clearer requirements.

It’s true

In any case, I thoroughly enjoyed the games for most of the 30 or so hours I spent on each, and I would recommend checking them out. What’s kind of admirable about The Lost Age is that they didn’t try to reinvent the gameplay significantly, they just took the original and made everything bigger and more impressive. Instead of two continents to explore, you’ve now got five continents and a bunch of smaller islands. Instead of walking everywhere, you now get a ship that also gets wings and the ability to fly. It’s like they wanted to make the coolest motherfucking ship ever, and they probably succeeded. I can tell you right now that if I had played it as a kid, I would be absolutely ecstatic about a flying boat.

More than I am now, I mean.

Look at canines: #000000 flag

2014-08-03T16:55:23Z

~~This~~ last month’s post is running late and I’ve come up with no real theme to talk about, so here’s a few scattered thoughts on some games I played recently, as if anyone actually gives a shit.

Assassin’s Creed IV surprised me. I was a fan of AC from the first up to Revelations, but then III turned out to be kind of shit and I basically lost any hope for the series. Along came IV, where they took the few things that worked in the previous one — like tree climbing, human shields, and sailing — and polished them so they became something you actually wanted to do. Pretty much everything in the game works really well and I don’t think I’ve ever been this fond of an Assassin’s Creed game before.

What’s more is the refreshing take on the protagonist. He’s not even an assassin, he just stole the clothes off one and bluffed his way through a bunch of tutorials. I also found the outside-Animus world with its clever jabs through the fourth wall much more interesting than the Desmond Miles story. I’ve always felt that the whole Animus deal was unnecessary — why not just be an assassin rather than a simulation of one? — but now we’re kinda stuck with it so anything that shifts the story focus to the part of the game everyone came to play is a plus in my book.

As for Watch Dogs, I initially thought strategic hacking would be the only viable way to progress, but it’s really more of an additional tool in your toolbox. At its core, the game is just a pretty good shooter/stealth game that also just happens to contain hacking. I had hoped for a hacking mechanic that entailed more than a contextual button press, but I guess it’s hard to make the Unix terminal exciting and I guess what we got is good enough. For a first try, I mean.

I like how, in classic video game logic, you can carry around all the weapons you’ve found, but it never gels with the rest of the game trying to be a Hollywood movie. There’s one cutscene where Aiden is forced to hand over his weapons and he gives the guy one measly handgun. The only thing I could think of was the truckload of assault rifles and shotguns I had been lugging around for the past few hours. Considering he passed the subsequent metal detector scan, the guy could probably make a pretty good living as an arms smuggler.

Enslaved: Odyssey to the West was better than I thought it would be. Gameplay is nothing to write home about, but the charming protagonists and colorful world are what sets it apart from being just average. I thought the facial animations were pretty spectacular, and they really helped bring some life to the characters. What a strange ending though. It looks like the game was nearing release and Ninja Theory went “fuck it, just put Andy in front of the camera and have him explain.”

I enjoyed Miasmata. Let it be known that there are problems with many aspects of the game, but one absolutely stand-out feature is the exploration. Finding your way around the island and mapping it out yourself is a really solid concept and I do wish more games would use something like it. I found the panther-cow-goat thing creepy the first few times but then it became more of a temporary nuisance than an actual threat, and I don’t think the game necessarily needed it.

One of my tensest moments was when I got lost in the middle of the woods at night and couldn’t find any known landmarks. The tension undoubtedly came from the knowledge that at any time, the creature could appear and kill me, costing me valuable progress, but had the fever and thirst been fatal, it would have the same effect. The game needs some sort of danger to provide consequence, but whether that comes from an aggressive creature or your own body turning against you is less important.

The bundle that included Miasmata also gave me Spate, which is one of those games few people ever hear about. After completing it in just short of 90 minutes I found out it was Kickstarter-funded with what looks like a fairly limited budget in this day and age. The game turned out alright, I guess. There isn’t much to it apart from some gorgeously weird set pieces, though I have to admit I also liked the tall robot dude who just seemed like a really nice guy. And ironically this next statement is coming from someone who is himself demonstrably bad at writing, but I do think the script could have used some work here and there (“having that moment of regret that hits a man right before the ground hits him” is an obvious candidate).

So I guess that’s a recap of the last couple of months. I’ve been spending lots of time with Golden Sun: The Lost Age as well. Hopefully I’ll get to complete it someday.

Horror without consequence isn't really horror

2014-06-17T17:22:13Z

Outlast is a pretty good game. The last chapter is kind of a letdown because the Walrider isn’t particularly frightening, but other than that the atmosphere is usually well crafted, and the infrared camera mechanic really adds to the experience. If there’s one thing you’ll see more than anything else though, it’s Saving … in the corner of the screen.

I’m not one of those people who despise checkpoints in general. In fact, I find frequent checkpoints an important feature because I for one don’t want to replay the entire level ten times before nailing it. Playing the same thing over and over gets real frustrating real fast, especially in games where you might suddenly be blown to bits by a grenade you had no chance of noticing. But this comes with a great big caveat: it severely diminishes any tension the game is trying to build up.

As with all horror games, the moment you figure out its patterns and limitations is the moment you stop fearing it. I remember how I was scared shitless the first time I played the original Slender, but with a few tricks — in particular, slow and calculated movements — it naturally lost much of its tension. This applies to Outlast as well; once you figure out that you can just hide in the same room again and again without the enemies getting any smarter, any actual fright is effectively destroyed.

Add to that the frequent checkpoints where dying robs you of very little progress and you realize that the best strategy might actually be to carelessly explore the level, reload and know exactly where to go and where to hide. That can’t be good for a genre that pretty much lives and dies by its ability to keep you on the edge of your seat. At least with Slender, you had to start over if you were caught, so that actually carried with it some consequence.

Don’t get me wrong, Outlast is still a good game, and I think one simple tweak could help the horror along: just don’t show the checkpoint notification. Without it, you wouldn’t know how far back dying would take you. While you’d probably still figure it out eventually, it would be less obvious from the get-go. A more involved tweak would be reducing the checkpoint frequency by half, but then you’re walking a fine line between tension and frustration, especially once the difficulty ramps up towards the end.

Immersion

2014-05-18T20:43:12Z

Whenever people ask me “Per, what is the most important aspect of an RPG?” I always answer “The game world”. No one ever asks me that, so I usually tell them preemptively. The most important part of an RPG is its world. There you go.

I recently tried out the very awkwardly named Monster Hunter Portable 3rd with two buddies and while they were going on about armor sets and crafting ingredients, I was mostly wondering how interesting the environments would be. As it turns out, not very, as each map is basically a bunch of small rooms linked together by portals. I rarely give a shit about stats and combat intricacies, so I was disappointed. I guess I’m a fucking casual.

Anyway, that made me think. If there’s anything emotionally meaningful that video games will probably always have over movies — you know, except for being fun and all that — it’s the ability to immerse. I enjoy movies as much as the next guy but when all is said and done it’s usually two hours of predetermined events, however well written or visually spectacular, in a world that doesn’t really exist beyond those two hours. This is true for a lot of games as well, but with RPGs in particular, you’ve often got a much more tangible world that doesn’t simply stop existing once the credits roll.

But you know what most certainly doesn’t add to the immersion? Receiving a Steam IM about cute kittens on YouTube. I speak from experience.

I’m one of those people who like to be reachable at any given time. Whenever my desktop PC is on (which is pretty much whenever I’m home) I’m online on Steam and Skype, and thanks to my phone I’m always reachable on Facebook, via e-mail, texts, or through a plain old phone call. Ah, the wonders of instant and ubiquitous communication. Where it gets annoying is when you’re in the middle of something else and the chat notification basically drags you feet first out into the harsh reality of expectations and responsibilities.

Back when I was younger I could spend hundreds of hours investigating every nook and cranny of each game. I realize this is very much #firstworldproblems, but obtaining a new game was a rare occurrence and you basically had to make do with what you had. I have the benefit of age and wisdom on my side (did I mention I’m in my early twenties?) to realize that wasn’t necessarily a bad thing. The fewer games you have in your backlog, the more you appreciate what you do have, and the less you’re inclined to just rush through it to the next one. And playing it at a slower pace makes it much easier for the immersion to kick in, even for a mediocre game. That’s my experience, anyway.

So the next time there’s a $1 Humble Bundle, maybe I should ask myself: do I really want to play these games? And the next time there’s an evening off for gaming, maybe I’ll just turn off everything but the game and give it my undivided attention for a few hours. Maybe. If I don’t end up slitting my wrists from communication withdrawal. We’ll see.