HERETIC DEVELOPER

Dev setup 2026

2026-04-30T00:00:00+02:00

My use case

I mainly work on a cross platform game written in C++.
With this purpose in mind this is my current dev setup as of 2026.

Clients

Main desktop PC

OS: Manjaro Linux x86_64
CPU: Intel i5-8400 (6) @ 4.000GHz
GPU: Intel CoffeeLake-S GT2 [UHD Graphics 630]
GPU: NVIDIA GeForce RTX 3060 12GB VRAM
RAM: 32GB

I do 90%+ of my computing on this machine.

Windows PC

I use this for debugging my game on Windows and for Photoshop.
It’s a Dell 7010 Thinclient.

OS: Windows
CPU: Intel i5 13500 / up to 4.8 GHz
GPU: GIGABYTE GeForce GT 1030 Low Profile
RAM: 16 GB

Laptop

When I travel or work not from home, I bring a MacBook Air M2.
I used to run a refurbished Thinkpad T495 (AMD Ryzen 3 PRO 3300U) running Linux.

I switched around October 2024, because I need to have an Apple machine to be able to compile for macOS. Also the overall quality of the MacBook is much better. Especially the trackpad and display.

Servers

Promox

Jenkins
Build nodes
- Windows 10
- Debian Linux (Linux and Emscripten builds)
- macOS (eventually)

I run this on a Fujitsu Esprimo E920.

Intel Core i5-4590 CPU @ 3.30GHz
16GB RAM
1TB HDD

Gitlab

I selfhost Gitlab on a Veriton N4640G Thinclient to be able to access my repos across devices, and to be able to build them using Jenkins.

OS: Debian Linux
CPU: Intel®Celeron® 3900T 2x2.60GHz
RAM: 8GB DDR4

Summary

I utilize cheap hardware to create selfhosted services. Most of the hardware mentioned I bought for about 100$ a piece off of Amazon. They’re not the latest and greatest, but they’re good enough for my setup.

In closing: To me infrastructure and data is more important than the machine I use to connect to it. As long as I can access my data and services I’m fine.

I plan on dowsizing my setup for future.
I haven’t fully figured out how to approach this, but I will do it eventually!

idTech 4 coding style

2025-11-14T00:00:00+01:00

idSoftware Coding Style (idTech4)

#programming #idsoftware #style

General

Use real tabs that equal 4 spaces.

Use typically trailing braces everywhere (if, else, functions, structures, typedefs, class definitions, etc.)

if ( x ) {
}

The else statement starts on the same line as the last closing brace.

if ( x ) {
} else {
}

Pad parenthesized expressions with spaces

if ( x ) {
}

Instead of

if (x) {
}

And

x = ( y * 0.5f );

Instead of

x = (y * 0.5f);

Use precision specification for floating point values unless there is an explicit need for a double.

float f = 0.5f;

Instead of

float f = 0.5;

And

float f = 1.0f;

Instead of

float f = 1.f;

Function names start with an upper case:

void Function( void );

In multi-word function names each word starts with an upper case:

void ThisFunctionDoesSomething( void );

The standard header for functions is:

/*
====================
FunctionName
Description
====================
*/

Variable names start with a lower case character.

float x;

In multi-word variable names the first word starts with a lower case character and each successive word starts with an upper case.

float maxDistanceFromPlane;

Typedef names use the same naming convention as variables, however they always end with “_t”.

typedef int fileHandle_t;

Struct names use the same naming convention as variables, however they always end with “_t”.

struct renderEntity_t;

Enum names use the same naming convention as variables, however they always end with “_t”. The enum constants use all upper case characters. Multiple words are separated with an underscore.

enum contact_t {
	CONTACT_NONE,
	CONTACT_EDGE,
	CONTACT_MODELVERTEX,
	CONTACT_TRMVERTEX
};

Names of recursive functions end with “_r”

void WalkBSP_r( int node );

Defined names use all upper case characters. Multiple words are separated with an underscore.

 #define SIDE_FRONT 0

Use ‘const’ as much as possible.

Use:

const int *p; // pointer to const int
int * const p; // const pointer to int
const int * const p; // const pointer to const int

Don’t use:

int const *p;

Style

Doom almost always sticks to a “no in-out” parameter policy; meaning all parameters to a function are either input or output never both.

Minimal Comments

Do not waste vertical space nor horizontal space

Minimal Templates

Use Orthodox C++ style of coding (C flavored C++)

Classes

The standard header for a class is:

/*
===============================================================================
Description
===============================================================================
*/

Class names start with “id” and each successive word starts with an upper case.

class idVec3;

Class variables have the same naming convention as variables.

class idVec3 {
	float x;
	float y;
	float z;
};

Class methods have the same naming convention as functions.

class idVec3 {
	float Length( void ) const;
};

Indent the names of class variables and class methods to make nice columns. The variable type or method return type is in the first column and the variable name or method name is in the second column.

class idVec3 {
	float         x;
	float         y;
	float         z;
	float         Length( void ) const;
	const float * ToFloatPtr( void ) const;

}

The * of the pointer is in the first column because it improves readability when considered part of the type.

Ording of class variables and methods should be as follows:

list of friend classes
public variables
public methods
protected variables
protected methods
private variables
private methods

This allows the public interface to be easily found at the beginning of the class.

Always make class methods ‘const’ when they do not modify any class variables.

Avoid use of ‘const_cast’. When object is needed to be modified, but only const versions are accessible, create a function that clearly gives an editable version of the object. This keeps the control of the ‘const-ness’ in the hands of the object and not the user.

Return ‘const’ objects unless the general usage of the object is to change its state. For example, media objects like idDecls should be const to a majority of the code, while idEntity objects tend to have their state modified by a variety of systems, and so are ok to leave non-const.

Function overloading should be avoided in most cases. For example, instead of:

const idAnim * GetAnim( int index ) const;
const idAnim * GetAnim( const char *name ) const;
const idAnim * GetAnim( float randomDiversity ) const;

Use:

const idAnim * GetAnimByIndex( int index ) const;
const idAnim * GetAnimByName( const char *name ) const;
const idAnim * GetRandomAnim( float randomDiversity ) const;

Explicitly named functions tend to be less prone to programmer error and inadvertent calls to functions due to wrong data types being passed in as arguments. Example:

Anim = GetAnim( 0 );

This could be meant as a call to get a random animation, but the compiler would interpret it as a call to get one by index.

Overloading functions for the sake of adding ‘const’ accessible function is allowable:

class idAnimatedEntity : public idEntity {
idAnimator *       GetAnimator( void );
const idAnimator * GetAnimator( void ) const;
};

In this case, a const version of GetAnimator was provided in order to allow GetAnimator to be called from const functions. Since idAnimatedEntity is normally a non-const object, this is allowable. For a media type, which is normally const, operator overloading should be avoided:

class idDeclMD5 : public idDecl {
const idMD5Anim * GetAnim( animHandle_t handle ) const;
idMD5Anim *       GetEditableAnim( animHandle_t handle );
};

id Studio Names

id<name>Dlg      // dialog class
id<name>Ctrl     // dialog control class
id<name>Frm      // frame window
id<name>View     // view window
id<name>         // any other class

File names

Each class should be in a seperate source file unless it makes sense to group several smaller classes.

The file name should be the same as the name of the class without the “id” prefix. (Upper/lower case is preserved.)

class idWinding;

files:

Winding.cpp
Winding.h

When a class spans across multiple files these files have a name that starts with the name of the class without “id”, followed by an underscore and a subsection name.

class idRenderWorld;

files:

RenderWorld_load.cpp
RenderWorld_demo.cpp
RenderWorld_portals.cpp

When a class is a public virtual interface to a subsystem the public interface is implemented in a header file with the name of the class without “id”. The definition of the class that implements the subsystem is placed in a header file with the name of the class without “id” and ends with “_local.h”. The implementation of the subsystem is placed in a cpp file with the name of the class without “id”.

class idRenderWorld;

RenderWorld.h // public virtual idRenderWorld interface
RenderWorld_local.h // definition of class idRenderWorldLocal
RenderWorld.cpp // implementation of idRenderWorldLocal

Prototype 0

2025-10-25T00:00:00+02:00

It’s more a tech test rather than a game.
The tech and infrastructure serves as the bones for everything to come.

Game rules

Kill enemies to gain score
Score ticks constantly down
Hitting enemies and collecting gems increases fire rate
Getting hit reduces HP and shrinks the game play area
Don’t get hit and don’t shoot for 5 seconds to gain HP
The higher the score, the more damage enemies deal

Controls

WASD - Movement
Space - Jump
ESC - Grab / release mouse
Mouse 1 / Primary fire
Mouse 2 / Secondary fire

V1.0 released on 25. October 2025

Dot Product Tricks

2025-10-25T00:00:00+02:00

When I first started 3D programming and came across the dot product, I was confused about it. I couldn’t wrap my head around how it could be used.

Here are some neat use cases I found throughout the years for it

It tells you how similar two normalized vectors are

The dot product returns a value in the range of [-1, +1].
+1 means the vectors are 100% the same
0 means that the vectors are perpendicular/orthogonal to each other
-1 means the vectors are pointing 100% in the opposite direction

float similarity = DotProduct(vec_a, vec_b);

Vector Projection

Remove a vector from another

In this example we cancel out the velocity in “gravity direction”.

// cancel out gravity part from velocity
const Vec3 vel = state.velocity - state.gravityNormal * DotProduct( state.velocity, state.gravityNormal );

This gives you the length of velocity in the gravity direction

DotProduct( state.velocity, state.gravityNormal )

Angle between two normalized vectors

This is useful when you want to get the angle between two vectors. float angle_rad = acosf(DotProduct(normalized_vec_a, normalized_vec_b));

Note that the range of angle will be 0° ≤ angle ≤ 180 degrees and the equivalent in radians 0° ≤ angle ≤ PI radians

The acos gives you only the magnitude of the angle between the vectors, it doesn’t give you the direction.

If you use this to rotate an object using this angle, you’ll need to make adjustment to the result if you want to make it look at a target for example.

// Define a normal (usually something like vec3(0, 0, 1) for XY plane)
vec3 normal = ...;

float angle = acos(DotProduct(normalized_a, normalized_b)); // 0 to π

vec3 cross = CrossProduct(normalized_a, normalized_b);

// Use the direction of the cross product to determine sign
if (DotProduct(cross, normal) < 0) {
    angle = 2 * M_PI - angle;
}

Clip vector to plane

I’m not sure what the proper terminology is to describe this, but you can use the dot product in the following way to change the length of vectorToClip so that it ends up on the plane normal.

Vec3 VectorClipToVectorPlane( const Vec3 &planeNormal, const Vec3 &vectorToClip ) {  
    return vectorToClip / DotProduct( planeNormal, vectorToClip );  
}

This clips the red vector to the plane of the black vector.

Visibility tests

Back face culling

If you want to check, you are viewing the front side of a triangle, you can use this. This can be used for checking, if something is looking at something

float backface_culled = DotProduct( plane_normal, view_dir );
if (backface_culled < 0)
{
// not visible
} 

float is_looking_at = DotProduct( enemy_view_dir, VectorNormalize( other_obj_pos - enemy_pos ) );

if (is_looking_at >= 0) 
{
	// sees the front face of the other object
}

View Cone Visibility

You can expand the above case to a view cone of a specified angle width

float is_looking_at = DotProduct( enemy_view_dir, VectorNormalize( other_obj_pos - enemy_pos ) );

const float DEGREES_TO_RADIANS = static_cast < float >( M_PI ) / 180.0f;
float dot_angles = cosf( 45.0f * DEGREES_TO_RADIANS );
if (is_looking_at >= dot_angles ) 
{
	// other object is in view cone of enemy
}

Vector Rejection (Coming soon)

Project onto plane

Wall sliding

Example book entry

2025-06-01T00:00:00+02:00

Use this post as a template: set cover to your jacket image (paths are relative to the site root), subtitle for a one-line summary, author, optional booklink for a store or reference URL, and category: [ books ] so it appears on the books page.

Meritocracy

2025-02-14T00:00:00+01:00

Academia went to shit in the last couple of decades, due to an influx of political correctness and other woke mindviruses, and bred new generations of ““yes-people””, who never question what they’ve been taught in university and who aren’t able to have an original thought on anything which might contradict what they’ve been told by authority.

These indoctrinated yes-man flood tech companies and produce slop by “design by committee”. There should always be one person in charge with a clear vision instead of a room full of confused people who only follow best practices and don’t have an inner monologue.

Companies don’t hire for skills anymore

In a world where meritocracy is viewed as racist and unfair, soon performance metrics will be viewed in the same way, because “youths” can’t rub two brain cells together to produce a solution. Mark my words, this will happen. You can clearly see the evidence in the web development sphere, where nowadays every retard can get a job as long as they have the correct pronouns, skin color or political beliefs.

If the tech sector doesn’t trim the fat, software development as a field is doomed.

Programming Philosophy

2024-05-10T00:00:00+02:00

Here are some insights of wisdom I picked up over the years.

Simplicity

Keeping it simple makes your code more robust, easier to debug, and allows you to come back to it and understand it quickly.

Don’t try to be smarter than you are. This will only hurt you in the future.

Like Terry Davis pointed out, the hardest question in programming is asking yourself

Is this niggerlicious or is this divine intellect?
Is this too much voodoo?

Focus on the problem not the programming

Don’t get caught up implementing “neat” solutions, which won’t add progress towards finishing your product, but will just “make the code better”. At this point it becomes programming porn.

Just because a solution is interesting to implement, does not mean that you need to implement it at all. You don’t need to always find the most optimal solution for everything. Sometimes a naive and straightforward solution will be more than sufficient.

You are building a product. Don’t fetishize code that much.

Generic solutions take longer

There is no need to try and think ahead into the future and generalize every little detail of your implementation to be more “flexible” in the future. There might not even be a need in the future for your use case.

You are basing your assumptions of the future on the problem you are solving in the present. The truth is that your are just guessing what you might need in the future. Most likely you will guess wrong and you will need to rewrite it anyway when it comes to it.

Perfectionism kills productivity

Trying to write perfect code is a waste of time.

Know the value of “good enough” and continue to solve other issues. It’s never going to be perfect and a good solution today is better than a closer to perfect solution tomorrow. Being productive is more important than being perfect.

Own your dependencies

You must not be dependend on binary distributions for libraries.

You’ll have trouble compiling your project for other platforms
You won’t be able to extent, fix or debug your dependencies
You can’t take a look and check what the code actually does

Hours in, is progress out

Keep grinding away on your project.
Each hour invested brings you closer to finishing your product.
There is light at the end of the tunnel!

Learn A Build System

2024-02-18T00:00:00+01:00

I had a colleague once, who suggested to me that I should learn CMake. This advice turned out to be golden, hence why I suggest to you the same. However you can chose to learn a different build system as well.

Knowing a build system is a game changer in how you setup and structure your projects. All of a sudden all your code can be generated/build on various platforms. You no longer need to know the individual, platform specific IDE project setup configurations. You can just learn the build system and it will setup everything correctly for your target.

This makes it easier for you to adopt the mindset that infrastructure is more important than the platform you are using. It allows you to switch operating systems whenever you want.

It makes adding external code easy! You can include other projects as part of your project.

It enables you to build your own work flows, as you can script in CMake. This means you can automate certain things. You can execute pre build steps and post build steps. Furthermore you can write code as part of the project and run it as a build step on your code base.

So far learning CMake had one of the biggest impacts on me as a programmer.

On Noise Cancelling

2023-08-06T00:00:00+02:00

When you want to program in complete silence without being disturbed by surrounding noise.

Brown Noise

Before you start looking into buying headphones, you should try listening to brown noise. Even, if you don’t have noise cancelling headphones, listening to low frequency brown noise blocks out a fair amount of ambient noise. Give it a try. It’s free.

Noise Cancelling

I don’t have any experience with active noise cancelling headphones, so I can’t talk about that. But, Passive noise cancelling works without batteries and doesn’t require an audio signal to block noise. However, there are passive ear muffs, which have an audio-jack, through which you can mix in brown noise to eliminate more sound from the surroundings.

🔥 HOT TIP🔥

There are Bluetooth audio adapters, which you can plug into any audio jack to make it able to receive audio signals via Bluetooth.

I use passive noise cancelling ear muffs with an audio-jack. I like these, because they aren’t really designed for “office use” but rather for the real world like construction sides, shooting ranges and military applications. You can expect high build quality and reliability. Also they’re cheaper. At first they’re super uncomfortable as they fit really tight on the head and ears. You’ll get used to it however after some time. I usually use mine with brown noise or some low frequency droning ambient music.

Improve Life Quality With A Rice Cooker

2023-08-06T00:00:00+02:00

If you are too lazy to cook for yourself, this is a MUST-HAVE. Rice cookers are underrated appliances, which in my opinion everybody should own. Not only can you cook rice in it, but all sorts of things like soups, potatoes, porridge, etc. You also can steam vegetables or dumplings at the same time. This reduces the effort to prepare a good meal to just a couple of steps.

Wash rice
Put washed rice into the rice cooker
Fill with water
Place dumplings into steaming compartment
While the rice is cooking, you can cut some fresh vegetables and prepare some meat

Rice cookers are very affordable, ranging from 30$ to upward of 100$. It really depends on what “features” you need. You don’t need a fancy one to get good results.

However when it comes to rice, I recommend buying high quality Japanese or Korean rice. They have a very pleasant consistency and in my opinion taste the best. It might cost more than the rice you can buy in your usual stores, but it’s worth to pay the premium.

Besides that you can buy the following extra ingredients to further expand the amount of recipes you can cook with it.

Get inspired by Japanese rice cooker recipes on YouTube.

Recommended Recipes

Get Books Before AI Ruins Knowledge

2023-08-06T00:00:00+02:00

The internet is quickly becoming an informational wasteland full with regurgitated bullshit.

It really doesn’t matter which topic you’re trying to look up. Usually you’ll find the same information phrased in a slightly different manner over and over again. It seems like that there is only one way of doing things in the modern era and everybody is just rephrasing it in their own words, presenting it as some sort of original work.

The things you can read online about any topic are mostly incomplete and are only scratching the surface. If you want to dig deeper it becomes almost impossible. Everybody keeps rewriting the same blog post again and again. YouTube isn’t really better in that regard. People are re-recording the same video with their own personal spin without any added value for the viewer.

With the advent of generative AI tools like ChatGPT, this problem will amplify itself times infinity. AI is becoming the single source of truth for the masses as it’s much easier for the bugmen to ask ChatGPT something, rather than coming to a conclusion of their own. Soon SEO optimized, AI generated content will flood the internet, drowning out, genuine knowledge and information even more.

It will become increasingly harder to find deep knowledge. This is why you should get books, while their content is still valuable and not generated by AI. Personally I prefer physical books, but you can get the digital versions as well. It’s up to you. Getting them digitally usually doesn’t require a lot of money, if at all. A lot of great books are circulating online as PDFs, ready to be downloaded.

Start building your library today.

Mouse Release For Debugging On Linux

2023-08-01T00:00:00+02:00

Debugging an application which captures your mouse cursor on Linux, leads to a problem where when a break point is triggered, it doesn’t release your mouse cursor.

For some people switching between windows with ALT + Tab makes the mouse reappear. However this doesn’t work for everybody and having to perform additional hand movements in order for the mouse to appear is annoying.

To solve this issue, we can write a script which will release the mouse automatically when a break point is hit.

Keep in mind, that this will only work for debugging with GDB

How to

Create a gdbinit file, if it doesn’t exist

mkdir -p ~/.config/gdb
nano ~/.config/gdb/gdbinit

Add the following content to the gdbinit file

set auto-load python-scripts on
source ~/config/gdb/release-mouse-gdb.py

Create the Python script

nano ~/config/gdb/release-mouse-gdb.py

Add the following content to script

#!/usr/bin/python

import os

def release_mouse (event):
    os.system("setxkbmap -option grab:break_actions")
    os.system("xdotool key XF86Ungrab")
    os.system("setxkbmap -option")

gdb.events.stop.connect(release_mouse)
gdb.write("GDB/X11: installed release mouse for X11\n")

That’s it! Just make sure to actually use GDB when debugging

References

github github github libsdl stackoverflow

Arguments against using Unity/Unreal

2023-07-01T00:00:00+02:00

Here are some points to think about before using Unity/Unreal:

Long Term Support

Compiling your game in five years might become challenging. Finding and setting up the right Unity/Unreal version could be tricky. Older versions may not support newer platforms. In that case, you will need to update your project to a more recent Unity/Unreal version, which may break things.

Compatibility

If you want to port your game to a platform that isn’t supported, you’ll run into a roadblock. Unity/Unreal needs to add support for it.You can’t do it yourself. This means your game’s compatibility and success ultimately depend on Unity/Unreal’s decisions.

Corporate Monopoly

Don’t contribute to building dystopian monopolies. Unreal and Unity are just centralizing power for globohomo.

Build Knowledge

Learn how game engines work. It’s fun writing stuff on your own and you learn how it works under the hood.

Start-Up

2022-06-30T00:00:00+02:00

I want to share my views on programming, video game development and technology.
I’ll publish code snippets and do write-ups on interesting topics.

I am working on a video game, which I’ll shill from time to time.

This blog is mainly for myself to keep track of my progress as some kind of journal.