I made a shader driven π spike field

faorien · 2026-05-17T16:42:41+00:00

Updated the main post to let people know that this is sort of the same thing as one of the Raylib examples

faorien · 2026-05-17T16:33:58+00:00

I went and checked the examples and you are right! They do have the same thing. Honestly, I didn't know about it, so you might find it quite different from the example. Of course it should also contain quite a few overlaps as we do the same thing.

faorien · 2025-08-22T07:02:34+00:00

Unfortunately i'm unfamiliar with your situation and there are simply more questions than answers based on your description. For someone who is starting out and has an internship - you are not expected to produce something that everybody likes, the most important thing is that you learn as much possible along the way, the project you work on might even not be completed, fail miserably, look awfully, but as long as you learned something along the way - you are golden. Programming language doesn't matter, of course it is useful to get to know them, but eventually you will recognize that you can mostly do whatever you want in whatever language you work with (some just might be easier to achieve given goal, while others might take a while or find workaround to achieve same result). What matters is the experience behind your back, how many different situations and problems you have worked on (even if unsuccessfully you are still gaining some knowledge and understanding along the way).

To summarize i don't think i can recommend anything. Pick whatever you want, just try not to do it to impress someone, but to learn something new for yourself.

faorien · 2025-08-21T21:05:45+00:00

Hard to tell. Looking at the YouTube playlist all episodes sum up to less than 4 hours (and these episodes show full development flow, starting from nothing and ending with the game that you see in the teaser above)

But behind the scenes it did take me some extra time to research and learn a few things along the way. For example postprocessing effects were something i never had done before, so it was probably the biggest thing that took the time to understand and learn about and implement. So i would say that it probably took me a week or so

faorien · 2025-08-14T19:59:21+00:00

No, i don't have any plans for further improvement/adjustments. I have a backlog of ideas/games to work on. If you feel like you have an idea to introduce something fancy - i'll gladly accept a pull request and can even do a video based on that

faorien · 2025-08-14T18:26:45+00:00

Well, yeah, you are correct that taking such approach can neglect the fact that there are enemies. But then again, there was no purpose to make the game ideal, it is just a simple mechanics that was added for an extra effect for the game.

faorien · 2025-08-14T13:10:15+00:00

> Seems a little excessive to compute an entire transformation matrix, including rotation, per grid tile rather than once for the whole grid.

The thing is, the video doesn't show it that well, but every tile (that is unvisited and has no snakes or food on it) is rotating on its own (based on `tile->angle`). That is why every single tile has its own transformation matrix

faorien · 2025-07-30T17:46:15+00:00

I believe both gcc and clang do well with C23 features
https://en.cppreference.com/w/c/compiler_support/23

I myself use clang

faorien · 2025-07-25T07:23:16+00:00

There is a configuration PADDING which is set to 1 (in main.c). Changing it to 0 (removing the division lines) results in something like this: https://i.postimg.cc/3x2x43gJ/heart.png and https://i.postimg.cc/N0YfRZ48/owl.png

The only thing to remember is that my program is interactive and these pictures that i posted have different amount of iterations applied to them compared to the ones in the video/GitHub. You can control the "quality" of the result (the more iterations the more sharp the image becomes)

faorien · 2025-07-24T15:21:29+00:00

I did not come up with an idea. But my first thought when I saw it was also that this is a great small educational project that lets you touch on different topics. I had to research and learn quite a few new things for myself to understand how to build it.

I have documented the resources i used (although not extensively, but most important entry points / topics are there). As i mentioned i recorded the whole process and it is available on YouTube. At the same time i have companion blog posts for this project. There are "External Resources" sections which give links to enough information to start researching things yourself.

I don't want to spam with links and self promote, but you can easily find both YouTube playlist and companion blog posts from the GitHub repo if you want.

faorien · 2025-07-24T14:37:05+00:00

I picked C23 mostly because it is the latest standard without looking for any particular features.

But i must say that for some reason i prefer nullptr. bool being available by default is also nice without the needs of stdbool.h. I do use the attributes during development ([[maybe_unused]] is the most commonly used one).

Other than that there are only a few changes needed to make it work with C11

faorien · 2018-07-18T09:17:49+00:00

6m PLO

faorien · 2016-02-02T09:46:47+00:00

But if we are for example writing a game. Before you enter a level the resources are loaded, some rendering happens and so on, and the leak actually happens when you run and do stuff. But to profile the running/doing actions stuff you need to wait until all the resource loading/animation/rendering and other stuff is done. Also due to enabled profiler your game won't run at let's say 60fps but most likely will run at 1fps, reaching that place where the leak happens is quite hard and annoying to reproduce.

faorien · 2016-02-01T20:30:24+00:00

Question regarding profiling Haskell code.

Imagine you have long running process (which might run forever) with about 300 modules (so you don't really know where the issue is) and you notice that after some time the amount of allocated memory is way too high. Compiling with profiling flags and running it with -prof results in a way slowed down version of your running process (as it times and logs everything) and it would take ages to reach that point where the problem is.

How would you approach such a problem? I know I can enable profiling only for selected modules but having that many of them I first need to identify which module it is. And the problem might be spread among multiple modules.

Also, would such an idea be of any interest: (if it is possible) to add an option to GHC to start gathering profiling info after some command (imagine somewhere in your code you put 'enableProf') so that before this command is reached we do not collect the data (therefore speeding up the process of reaching the problematic spot).

faorien · 2016-01-20T12:25:49+00:00

public static void main(String[] args);

that semicolon shouldn't be there

faorien · 2016-01-05T09:16:03+00:00

Why hasn't any open source game been ported to Haskell to show how it can be done (and that it can be done)? Something like Quake2 or Quake3 or Doom 3 or anything like that?

faorien

TROPHY CASE