With Windows 10 reaching EOL and with all the hype about Steam on Linux, I finally decided to format my old desktop and install PopOS.

I haven't seriously used desktop Linux in a while (almost a decade), however I used PopOS in a VM a while ago and was quite happy. I also wanted something that "just works", and PopOS promised just that.

Overall and I've got to say... I'm a bit disappointed with the current status of desktop Linux. I've got everything working now, but there's no way some things would be acceptable for a non-technical user.

I was mostly surprised with Flatpak and the amount of tweaks that I have to do with Flatseal... For something that seems to be the recommended install method in the Pop!Shop, I would expect most things to just work . Instead, by default:

• Steam doesn't let you setup alternative install directories

• VLC doesn't have GPU acceleration

• Syncthing (via Syncthingy) cannot run in background mode

  Also, getting Steam to install games to a separate drive was such a pain in the ass (mostly because steam silently fails, but also due to some quirks with auto-mounting)...

  Hopefully things will get better in the near future, but 2024 is clearly not yet the year of Linux desktop.

Quick update on the rasterizer thing. I got the a rotating Stanford bunny (~70k tris) rendering at 10-15 FPS (~30-35 FPS if static).

I think this is as far as I'll go for now.

By the way, for those that want to try to implement something like this, the implementation was heavily based on https://jtsorlinis.github.io/rendering-tutorial/

A very short and sweet tutorial on rasterization, with some nice interactive demos.

I had a long weekend, so I decided to take a quick look onto adding geometric primitives to Minart (inspired by https://github.com/JD557/minart/issues/514)

After writing the rasterizer, I couldn't resist to give it a spin (pun not intended) with a basic 3D software renderer.

I was expecting to be able to draw ~10 polygons on screen, but it went better than expected. My demo was running ~500 "flat-shaded" quads (I cheated a bit on the shading) at more than 60 FPS with no issue (it started to struggle at about 2k).

While not very impressive for a 3D engine, that was never the goal. I think this should be more than enough for basic polygon drawing use cases.

Over the last few weeks I've been playing around with building a simple caffeine tracker app for Android app with Scala.js and Tyrian.

It's not super polished, but it was a fun experiment: https://github.com/JD557/coffee-tracker

I also wrote a blog post detailing the experience:

https://blog.joaocosta.eu/articles/8cd240f/writing-an-android-app-with-scalajs

Just signed the Stop Killing Games EU Citizen's Initiative.

This initiative calls to require publishers that sell or license videogames to consumers in the European Union (or related features and assets sold for videogames they operate) to leave said videogames in a functional (playable) state.

Specifically, the initiative seeks to prevent the remote disabling of videogames by the publishers, before providing reasonable means to continue functioning of said videogames without the involvement from the side of the publisher.

The initiative does not seek to acquire ownership of said videogames, associated intellectual rights or monetization rights, neither does it expect the publisher to provide resources for the said videogame once they discontinue it while leaving it in a reasonably functional (playable) state.

More info: https://www.stopkillinggames.com/eci

Petition: https://eci.ec.europa.eu/045/public/#/screen/home

#stopkillinggames

I was checking out HTMX (downloaded the docs to read during the flight) and decided to add some sprinkles to this blog.

I want to keep this site working without any JS, so I just went for the basic hx-boost and hx-indicator.

I'm amazed by how well "It Just Works".

It's obviously not as nice as a more complex JS integration, but it's such a quick win that I might start using this more often.

Here's RokRok, a Gopher Client written in Scala: https://github.com/JD557/rokrok

This is mostly a toy project to try out Minart + InterIm + Scala Native Multithreading, so don't expect too much.

I do plan to work on it a bit more, as it is a nice way to test InterIm features.

Just released InterIm 0.2.0, with Scala Native 0.5 support, implicit component layouts and some critical bug fixes.

https://github.com/JD557/interim/releases/tag/v0.2.0

I'll try to update Spaeti and finally release my Gopher client demo using this version soon.

Finally released the final version of Minart 0.6.0: https://github.com/JD557/minart/releases/tag/v0.6.0

This version drops Scala 2 support and updates Scala Native to 0.5. The Minart Pure module was also removed.

This version has been in the oven for a while, so it includes a ton of bug fixes since 0.5.3.

Just released Minart 0.6.0-M3 with Scala Native 0.5.0 support.

https://github.com/JD557/minart/releases/tag/v0.6.0-M3

This version might be (even) more unstable than usual, but I wanted to get it out ASAP to find as many bugs as possible before the proper 0.6.0 release.

Looks like Manning has some free books, courtesy of some sponsors at https://www.manning.com/corporate-splash

I've read "Data Pipelines with Apache Airflow" and can definitely recommend it if you are into data engineering and want to learn more about Airflow data pipelines.

This weekend I was playing around with defining an animation DSL.

I've wanted to play this for a while after watching @davesmith00000's interview for "Scala for Fun & Profit" and @kubukoz Playdate talk. Everyone's doing DSLs for gamedev!

It's still quite rough, but I think it's useful for things like menu animations. Maybe I'll use something like this in the next GameJam entry to add a bit more juice to the menus.

This example looks like this:

  val backgroundAnimation = {
    linear(0, 512, 10.0).loop
      .map(delta => (delta.toInt, delta.toInt))
      .translateWrap
  }

  val baloonAnimation = {
    val rotation =
      (linear(-Math.PI / 32, Math.PI / 32, 1.0) >> linear(Math.PI / 32, -Math.PI / 32, 1.0)).rotate
    val beat =
      (easeOut(1.2, 0.9, 0.5) >> easeIn(0.9, 1.0, 0.1)).scaleXY

    (rotation && beat).loop.map(asSurfaceTransform)
  }

  val textAnimation = {
    val rotation =
      (easeIn(-Math.PI / 32, Math.PI / 32, 1.0) >> easeIn(Math.PI / 32, -Math.PI / 32, 1.0)).rotate
    val beat =
      (easeIn(1.3, 0.9, 0.5) >> easeIn(0.8, 1.0, 0.1)).scaleXY

    (rotation && beat).loop.map(asSurfaceTransform)
  }

#ScreenshotSaturday

All setup to go to Lambda Days 2024 in 2 months!

Due to the available flights, we'll go a few days earlier. Any recommendations for cool things to do/see/eat in Krakow?

On my previous job at Zalando I had multiple co-workers that kept a paper journal.

I tried to keep a digital journal in the past with VimWiki, but was quite unsuccessful at that. It's just too easy for me to paste random stuff there and make the journal a mess.

So, now that I changed jobs (and got a free notebook), I decided to give physical journaling a try.

I've been doing it for about a month and I'm enjoying it a lot. Just the simple act of checking "what I did yesterday" and writing "what I need to do today" (with no copy paste) really helps me focus.

On that note, since I started writing more, I decided to get a slightly better pen (I was using freebie pens). While I was in college I used a lot of Uni-ball Signo pens (usually either 0.5mm or 0.7mm), so I decided to try those again.

I forgot how smooth it feels to write with them, I need to get used to it, but it does feel nice