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.

spotlight

I spent about 2 weeks on spotlight, my hugo blog featuring pretty windows spotlight images. My windows have stopped showing me new images, not sure what’s up with that so the contributions have more or less stopped. I should learn about how image processing works and publish it this year.

Star trek

The year started with me watching star trek TNG and desperately watching the full series of deep space 9 before it was removed from netflix the last 2 to 3 weeks of the year.

dotgrid

Similarly the year started with me porting 100 rabbits dotgrid to typescript and letting it wait before digging deep and spending 5 weeks in november/december doing the final steps. There are still some things left that I’ll hopefully finish in 2026.

ubiquity

Another thing that I hopefully can finish or at least continue work on is ubiquity, the mozilla not-ai NLP-based command-line/prompt. I liked the deterministic “ai” prompting and the auto complete like suggestions it could provide. Unfortunately my initial attempt on porting it was unsuccessful and I think I need to do another try this year.

smide/forma

Speaking of AI, I spent about 4 weeks on both smide and forma.

Smide is an exploration and collection of code generators where you write input in one format, say XML and together with a template like mustache you can generate code.

Forma is a typesafe c++ template engine, originally from blaggen and c#, where you compile a template and a pattern and get back a function specifically for that template. This allows you to check for template syntax errors and then generate or not, instead of most/all template engines that don’t have that pre-step so syntax errors are generated (and reported) for each generated call.

Neither project has ended up in production.

poster tester

Poster tester also got some love, I added icons for all requests and added basic support for endpoints that require authorization. While nothing major I still continue to use and find use for it.

ride/pony

From a ride perspective the year started great with continued work on pony, the “vs code” version of ride classic, Prototype Of the New Year or pony. Unfortunately I hit a snag when I decided to rewrite all path types so they are either a valid directory or a valid file and I lost momentum and put it on ice. It wasn’t until at the very end I grew tired of vs code and little by litte continued the work. I’m currently working on replacing the syntax coloring selection but it is also kinda back on ice since I want to continue work on euphoria/klotter again.

euph/workbench

The start of the year continued where the previous left and that was replacing codecov and coveralls with something that can be run locally, complete with a badge that can be displayed on the readme. Then I got an error with my clang-tidy warning parser and I decided that I should solve it with unit testing so that’s what I did.

On the euphoria side of workbench I fixed clang-tidy warnings and got 100% on function coverage for the base library.

klotter

Most of the year was spent on klotter. The first month of development I did rendering multiple objects of the same type with different transforms, aka instancing. I learned about linear vs non linear colors and added basic antialiasing support via MSAA. And was troubled by a bug that took a week to find.

glox

At this time I grew tired of spending a week on tracking down a bug that only was due to a typo and wanted a typesafe Open GL, explicitly where all enum values were valid for all enum types. I spent a few (2) weeks on a typesafe generator that I could use instead of glad and that could turn a week of bug hunting into a 5 second compile error. I called it glox.

Fortunately a helpful soul told me that my error reporter also sent invalid enum values and after fixing that (and some other) errors it became a runtime error. It’s still not as good as a compile time error but it’s good enough and I can use standard practices instead of spending a few months (at least) on fixing all the compatibility issues that my generator would have.

So I went back to work on klotter.

more klotter work

What the experience taught me was that RenderDoc is important as is finding information in it fast. So I spent the following week labeling all OpenGL objects so they are readable in RenderDoc. I continued with removing workbench build and just using straight cmake for dependencies with options to disable the labeling when making a dist build.

With that out of the way was adding a initial HDR renderer with bloom and knee support so the bloom/not-bloom transition isn’t hard. There is still much to be done, improving the bloom and adding autoexpose but I tabled that for a later day.

At this point in our story we are in september and I realized that I won’t be completing the car game and I lost momentum. After a month I had added directional shadows with PCF filtering and upgraded the dear imgui to the latest version but that was kinda it for that year. There is still much to be done, but my goal remains from last year: Make an arcade game before the end of the year.

visual debug

With the momentum gone I went looking for greener pastures. I rediscovered Sebastian Lagues visual debugger and wanted something similar so I started “porting” that to klotter and started implementing that but never completed it.

samling

In between klotter work, and around the time that black week/cyber monday hit, I was looking at various deals for assets and wondering what assets I own and the overlap was. So a thought popped up into my mind, what if there was a tool that could tell me that. The answer was samling, a small application where you could add entries and display them. The overlap and merging of collections is still, after 2 weeks, not implemented. Perhaps next year when black week comes back.

blaggen

One thing I didn’t work on, but want to continue on, is blaggen, my static page generator. I’ve been also thinking about perhaps learning go and see if I can add the compilation step to hugo but I at least want to continue work and at least make it usable. THe compilation step isn’t implemented and I know for a fact that I want to change how templates are applied and I come to like how hugo has done it so I probably just going to copy that. Hopefully I can do that this year, let’s see.

altdev and other conservation projects

One thing I didn’t work much on was altdev and other conservation projects. I want to publish the altdev and get more eyeballs on it.

conclusion

Yeah. I didn’t finish the arcade game :(

So that leaves only my goals:

1. As I just said, I would like to publish an initial version of altdev
2. and as mentioned earlier I would like to at least complete the klotter project and get the renderer done. Hopefully that will also include a arcade racer
3. and complete blaggen of course, if only to demonstrate the USP
4. and finish the spotlight page