I recently realized that I’ve been writing my devlog since 2017 but I have never compiled all the devblogs into a longer post starting from today. I’ll summarize and write a smallish review of what I’ve done on all my hobby projects the past year.

Euphoria

Euphoria is my hobby game engine and to much surprise I did a couple of cool things related to it.

Code wise I’ve continued to code cleanup (replacing streams with fmt), both warnings and enabled warning-as-errors(with w4/Wall+extra), I also added both a clang-tidy and coverage step on github actions so I can keep the code clean and strive towards a 100% coverage for the core. Added a PCH cut the compilation time by roughly 66%.

Feature wise most user facing would be the “through the lens” camera movement in the world/level editor t3d and 3d world selection and item movements .

Tred

Speaking of euphoria, the next version of euphoria rendering, tred got a cleanup and refactor, and I started added the world concept.

Fyro

I also got excited about the thought of a simple engine, something like a pico-8 love2d mashup and forked the 2d rendering from tred and started removing all 3d and simplifying it and calling it Fyro . This split allowed tred to focus on 3d with 2d and fyro to only focus on 2d. The 2d sample games was moved to fyro.

Currently there is a working snake clone complete with rumble input and local multiplayer. There is also a 2d platformer base complete with pixel perfect collision (inspired by celeste and towerfall ), tiled loading and camera movement. All this is controlled by a custom scripting language and that brings us to the next project.

Lox

I read the first part of crafting interpreters , implemented my custom version, still called lox and continued adding on it. If I have any new year resolution is that I should read the second chapter and learn about virtual machines, bytecodes and how to optimize the scripting language.

Workbench

Looping back to work that I did for euphoria, it wouldn’t be possible without the build/workbench project. This year I came to the realization that python, while nice to work with, doesn’t really result in easy to maintain programs when they grow beyond a certain size and my c++ helper scripts, I think, have reached that size. So in 2022 I have explored 2 different languages: rust and c#. The rust port is further along, and in some ways have more features than the python version and while I like the language and I don’t particularly like to read the code and feel like a variable very often always have the wrong type.

So I tried c# now that Linux support isn’t a afterthought and I know from work projects that I both like c# and it’s libraries. I encountered a roadblock however in that a nop-build is way slower than both c++ and rust, and since I’m integrating it into console applications I mostly tend to do nop builds when developing.

Clean code

I started reading clean code and wrote a post about the “first” (second) chapter . I also read the “second” (third) chapter and wrote a post about it but since then I learned about what some part actually means so I have yet to rewrite the post and publish it. Another resolution: rewrite that blog post!

Postertester

In between all the c++ and rust I added a few nice to have features to my postman clone/replacement and published the repo. There are still some things to be done before releasing 1.0 and calling it feature complete.

Other tidbits

I joined a gamejam and created a game . I would have made a much better game if I didn’t get distracted and started writing my own physics engine.

For my text editor ride I realized I could just copy the fyro code and do the rendering with OpenGL. This turns out works great on Linux but on windows it tends to be a bit laggy. I’m still not sure and I wonder if I have this effect with the older renderers and just didn’t notice so I slowly started bringing back part of the old structure where I could test out different rendering APIs for freeform application development. It’s still a work in progress but something I hope to continue with in 2023.

I watched a part of talk by Nikita about alabaster but didn’t like the colors so I started work on a solarized version , but found bugs in VS code and couldn’t continue.

After watching both Star Trek: Voyager and Star Trek: Enterprise I decided I would start from well… the start so I watched the original series . While I wouldn’t say the episodes are great there are some really great ones, and probably at one point I’m going to write a blog post about the great episodes so I won’t forget what they are.

Another year full of devlogs and another review of what I have achieved and failed to achieve.

workbench, euphoria, gaf and json

Workbench started out as a repo of various build scripts, but is now a single tool for running all those “scripts”. This year I ported everything from rust to c# and scoured my repos for other tools to integrate it into the code base.

One of the big reasons for choosing C# is so that I can use the spectre project to get a nicer cli. The other big reason is that I use c# as a language for work so I’m very familiar with it. I can also use resharper to clean up the code and do major refactorings, that wasn’t really possible with the rust or the python version.

When the code got better I could integrate more tools, like code city, extract data to a word cloud and a “code-age histogram”. Some tools use git porcelain mode, some parse the doxygen XML output for code understanding.

For euphoria I mostly watched various talks, about localization, AI and entity system that made me realize how to mostly (re) structure my entity system and now I have a rough plan on how to proceed and what features to add (and remove). I switched to the main workbench branch and started replacing some custom scripts with the new c# based workbench and basically just started fixing the issues it found.

I realized that the goal of my “protobuf” library gaf was way to complex and too big for me to handle so I started replacing the gaf usage in euphoria with just a simple json library (my own). In 2024 I will archive the gaf repo since, as far as I know there are no users and it will not be completed (by me).

blaggen

How hard can it be to write a static page generator? That is a terrible question for a “create a new project a week” addict like myself. Blaggen is my answer to that “question”. I started out using mustache but ended up writing my own template engine that has a few nice features and can “error out” when you use a property that hasn’t been registered.

The big USP is adding custom compile steps, so one could compile, run code examples, write unit tests and insert outputs from those runs. I still like the project and want to continue work on it, unless I start adding the USP to hugo.

Currently it’s not useful and it’s missing hot reload (and file copying) but that’s only because I got motivated to work on tred/klotter again. In 2024 I want to either complete or archive it since it’s kinda thorn in my side, sitting there waiting…

tred is dead, long live klotter

I continued work on tred but came to the understanding that tred focused too much on code quality and best practices. While revision system is better than arc for memory handling, focusing on the best allocation strategy and code abstractions while also trying to get a good rendering API with all features turned out to be much and I lost focus on the rendering. So I started work on klotter. The same basic goal as tred, that is> at some point in the future to integrate it into euphoria, but there is now also anti goals of not focusing on allocation and code prettiness so it doesn’t end up in the same place as tred.

ride

I solved the laggy rendering on windows, making the other rendering backends less relevant, since if you only use one backend the other rot and just make the code more complex.

Every time I use another editor like vs code and notice something I don’t like , I often wonder how much better ride could be for my use case. For 2024 I want to continue the work on ride and perhaps get it to a working state and while it probably won’t end up as my daily driver for quite a while I want to be able to use it, at least, for a short time.

smaller projects and other tidbits

I started porting bosca ceoil to c++ and started work on a vector graphics editor called vecy. I’m not sure I’m going to complete either but a simple vector editor is something I’m missing.

I also started reading the second chapter of crafting interpreters and hopefully in 2024 I can upgrade lox to a much better system.

conclusion

I did the first review in 2022 so this is the second one.

Looking back: fyro ended up on the ice this year but that’s mostly because I just recently started reading the second part of crafting interpreters , in 2024 I will continue the work or at least upgrade the interpreter.

I started reading clean code and a resolution for 2023 was to continue reading and rewrite the blog post about that last chapter. That hasn’t happened, so I guess I can repeat what I said last year for 2024

rewrite that blog post!

I also haven’t written a blog post about the great episodes of star trek voyager, the original series and the animated series that I wanted to do last year. My star trek marathon took a break in season 1 of star trek the next generation so this year I should really be watching more star trek!

But I did fix the issue in ride and even though tred “died” it served the lessons and the good code I wrote for it have, or will, be merged into euphoria euphoria (hopefully in the near future).

If there is any goal I really want to complete it is that klotter should be complete and integrated back into euphoria with the new and improved entity system and using lox so I can finally start making some basic 3d games using my own engine.

So… lots of stuff to do in 2024

games

THe only game I made this year, was a game made in 4 hours for the spelsylt gamejam.

I think one of my new years resolutions will be making and publishing the car game is some way or another. I’m really keen on working on the arcade car game.

klotter

The year started strong with implementing framebuffer/post proc, cubemaps, skyboxes and uniform buffers and continued with code cleaning in the end of february but then I just stopped and was stuck on instancing and having some sort of analysis paralysis and ignoring for most of the year before almost completing it before the end.

learning and planning

Instead of klotter I found other work, I looked into how to implement finite state machines, gui development, portal rendering and worked on reading the jedi knight academy source.

animation/vita

I read most chapters of a animation book over the course of about 2 months, only skipping the crowd rendering, and that resulted in the mini-engine vita . I won’t use the code directly in euphoria but it was a good experimentation.

euphoria/workbench

I did work on workbench, my c# build tool and source code status app, not a major overhaul or anything but I optimized the clang-tidy build and ended the year by starting to replace the external coverage reporter with a workbench one that I can run locally. For euph I upgraded the ubuntu builder and moved most of the code to a legacy folder so I can focus on the car game.

When that is done I can start working on the new dear imgui based editor app with undo/redo support, at least until the 3d rendering is “done”.

blaggen

My static page generator didn’t get much love this year, just some small fixes and a upgrade to the latest LTS. I want to complete at some point as it has some cool unique features.

ride

I think my ride editor will get most of my focus this year. I can remove most of the rust parts and make a generic “vs code” like and “prototype of the new year” is a good name.

genesis3d

Genesis 3d is a old engine and I stated thinking about the API and how easy it was to use. I spent a month convering the c headers to c++ and added moved the documentation to a doxygen compatible headers. I realized that having some basic api documentation in plain english is kinda nice when trying to figure out why a function fails.

altdev & flipcode

About 4 months of the year was spent on cloning and converting a old blog called “altdev” from internet archive to hugo. It’s close to completion but not yet ready for publication.

I also looked at flipcode. It still is online but the mobile version is pretty bad and it would be nice if it was better.

For some reason I have been thinking much about having a local archive of your favorite (static) webpages.

blender

I finished both the blender “rite of passage” donut tutorial and the anvil. Hopefully there will be more finished blender products this year.

fyro & lox

For lox, I remove dthe public/private requirement and moving it in a more typescript direction than the original c# direction. I also started on type information but decided that it would be better to actually continue by making the interpreter into a compiler and vm structure. The other side of this project was a lot of fyro work and preparing for object-object collision that will be based on the type system, but since that is tabled for later so will the object-object collision.

bookshelf

I like to read when I’m commuting by train and for this winter season when I’m commuiting I decided to rrevive and an old project and convert it to a hugo theme. This is bookshelf, a book like theme with some sample books that I can read on my train rides.

conclusion

Last year I concluded with

If there is any goal I really want to complete it is that klotter should be complete and integrated back into euphoria with the new and improved entity system and using lox so I can finally start making some basic 3d games using my own engine.

lol

Hope this year will be better and more of my predictions/plans will come true.