gunslinger VS rotate

Here's a framework that's cool: https://github.com/MrFrenik/gunslinger/. We have a great Discord community, too. Even if you don't end up using it, there are plenty of people who are willing to offer guidance regardless :). Invite link is on the author's YouTube channel: https://www.youtube.com/watch?v=-_HxKDNuCqA

Check out gunslinger, a pure C99 game framework, with a very clean design.

The development has been making huge strides and they have a fairly active discord channel:

https://github.com/MrFrenik/gunslinger

Make your own. If you really want to make a game in C, this may be the best option. Depending on how complex the game is that you want to make, this could be an enormous task, or not too big of a deal, in some cases it could even be easier than learning a game engine. You can use frameworks like Gunslinger to make it easier, as well. If you need guidance, the Gunslinger community is friendly and accepting of beginners :).

That being said, you may have your requirements satisfied with tagged unions which consists in implementing a struct with an anonymous union and label (like an enum) to keep track of what data is inside the union, this works really well when you know beforehand which data types you want to support. Another technique could be using macros, like the containers on the gunslinger framework, however I have never implemented something like this. Lastly you can always use void pointers, however you may need to be more clever to achieve it (I almost never use them).

Some of my favorites are: sokol/pacman.c, Gunslinger, and gb

And here is Github of his game engine of this guy: Gunslinger Game Engine

To install non exotic library from a github repo, specify just the repo-owner/repo-name or the absolute github link to the repo. E.g. to install gunslinger and stb from master branch

Looking quickly at this lib, functions of the API are not static: https://github.com/MrFrenik/gunslinger/blob/d5ebcce0647e97badc9337749d7cd9f5810eecfa/gs.h#L1415, so it might lead to ODR violation.

quadsort/fluxsort/crumsort author here.

For me there's a strong visual component, perhaps most obvious for my work on array rotation algorithms.

https://github.com/scandum/rotate

There's also the ability to notice strange/curious/discordant things, and either connect the dots through trying semi-random things, as well as sudden insights which seem to be partially subconscious.

One of my (many) theories is that I have the ability to use long-term memory in a quasi-similar manner to short-term memory for problem solving. My IQ is in the 120-130 range, I suffer from hypervigilance, so it's generally on the lower end due to lack of sleep.

I'd say there's a strong creative aspect. If I could redo life I might try my hand at music.

This is essentially just a rotation of a subrange of your original array. A variety of different algorithms for this operation can be found here.

Memory bandwidth is 1000x lower than CPU bandwidth, so as a rule of thumb any algorithm whose work scales linearly in the amount of data being processed will be memory bandwidth bound, and also any algorithm which can't be structured to do a lot of work on one memory region at once before moving onto the next one.

Examples (for large enough inputs that it's relevant) include shuffling, sorting, kmeans clustering, branch and bound sudoku solving, vector addition, dot products, and so on.

Moreover, writing a particular piece of code is often easier if you ignore memory bandwidth as a constraint. The classic example is matrix multiplication -- it can be structured such that even disk bandwidth isn't relevant compared to CPU bandwidth, but doing so is a little fiddly compared to the naive n^2 dot products approach, so writing it yourself usually results in a memory bandwidth bound solution for large matrices.

Similarly, writing two passes over your data rather than doing a mega-loop, the choice to use classic kmeans rather than one of its approximations (when it would be appropriate to do so), or not enforcing sortedness at some reasonable boundary and having to do additional passes over your data. It's easy to write code that hoovers up way more bandwidth than it needs to, and often faster algorithms that come out don't do anything different than access the right data at the right time to reduce that pressure, like a trinity rotation [0].

Caveat: Benchmark everything, especially as you're building intuition. Trying to fix what you think is a memory bandwidth issue can result in pipeline stalls and all sorts of fun things, especially when your server has more faster caches than your dev machine, when data in prod doesn't match your micro benchmark, ....

[0] https://github.com/scandum/rotate