Particle families and setup

Each family owns numberOfParticles lightweight Particle instances with positions, velocities, and a max speed limit. They spawn inside a circle and receive randomized velocities before Unity instantiates a prefab for each one. The simulator also generates a unique AnimationCurve plus [minDist, maxDist] for every ordered pair (A->B, B->C, etc.), so every run uses a fresh rule set.

void Start()
{
  // allocate particles/transforms per family
  ParticlesA = new Particle[numberOfParticles];
  ParticlesB = new Particle[numberOfParticles];
  ParticlesC = new Particle[numberOfParticles];
  ParticlesD = new Particle[numberOfParticles];
  
TransformsA = new Transform[numberOfParticles];
  TransformsB = new Transform[numberOfParticles];
  TransformsC = new Transform[numberOfParticles];
  TransformsD = new Transform[numberOfParticles];
  
 // spawn each family with random position/velocity, then instantiate
  for (int j = 0; j < numberOfParticles; j++)
  {
    ParticlesA[j] = new Particle(RandomPosition(), RandomVelosity(), VelosityMax);
    ParticlesB[j] = new Particle(RandomPosition(), RandomVelosity(), VelosityMax);
    ParticlesC[j] = new Particle(RandomPosition(), RandomVelosity(), VelosityMax);
    ParticlesD[j] = new Particle(RandomPosition(), RandomVelosity(), VelosityMax);
    
 TransformsA[j] = Instantiate(particlePrefabA, ParticlesA[j].position, Quaternion.identity, null).transform;
    TransformsB[j] = Instantiate(particlePrefabB, ParticlesB[j].position, Quaternion.identity, null).transform;
    TransformsC[j] = Instantiate(particlePrefabC, ParticlesC[j].position, Quaternion.identity, null).transform;
    TransformsD[j] = Instantiate(particlePrefabD, ParticlesD[j].position, Quaternion.identity, null).transform;
  }
}

void Start()
{
  // allocate particles/transforms per family
  ParticlesA = new Particle[numberOfParticles];
  ParticlesB = new Particle[numberOfParticles];
  ParticlesC = new Particle[numberOfParticles];
  ParticlesD = new Particle[numberOfParticles];
  
TransformsA = new Transform[numberOfParticles];
  TransformsB = new Transform[numberOfParticles];
  TransformsC = new Transform[numberOfParticles];
  TransformsD = new Transform[numberOfParticles];
  
 // spawn each family with random position/velocity, then instantiate
  for (int j = 0; j < numberOfParticles; j++)
  {
    ParticlesA[j] = new Particle(RandomPosition(), RandomVelosity(), VelosityMax);
    ParticlesB[j] = new Particle(RandomPosition(), RandomVelosity(), VelosityMax);
    ParticlesC[j] = new Particle(RandomPosition(), RandomVelosity(), VelosityMax);
    ParticlesD[j] = new Particle(RandomPosition(), RandomVelosity(), VelosityMax);
    
 TransformsA[j] = Instantiate(particlePrefabA, ParticlesA[j].position, Quaternion.identity, null).transform;
    TransformsB[j] = Instantiate(particlePrefabB, ParticlesB[j].position, Quaternion.identity, null).transform;
    TransformsC[j] = Instantiate(particlePrefabC, ParticlesC[j].position, Quaternion.identity, null).transform;
    TransformsD[j] = Instantiate(particlePrefabD, ParticlesD[j].position, Quaternion.identity, null).transform;
  }
}


How it works

• Each frame recomputes the force on every particle by summing contributions from the other three families. GetForceA/GetForceB/… just call the shared CalculateForce helper with the corresponding SpatialGrid, Particle[], and InteractionConfig.
• CalculateForce only visits nearby particles by hashing them into a grid whose cell size matches the longest interaction radius. It loops over neighboring cells up to cellRadius, so it never misses an influencer without scanning the whole population.
• Only distances within [minDist², maxDist²] participate. The code normalizes the true distance to [0, 1] via (distance – minDist) / (maxDist – minDist) and samples the cached AnimationCurve, multiplying the scalar by forceScaler and the normalized displacement direction.
• Every computed force is scaled by Time.deltaTime, passed to Particle.ApplyForce, and then the particle’s position is updated and bounded (the current Wrap is a no-op, so the bounds are more aspirational for now).

Private Vector2 CalculateForce(Particle source, SpatialGrid grid, Particle[] targets, InteractionConfig config)
  if (source == null || grid == null || targets == null || config.maxDist <= config.minDist)
    return Vector2.zero;
  
  grid.GetCell(source.position, out int x, out int y);
  Vector2 force = Vector2.zero;
  for (int offsetX = -config.cellRadius; offsetX <= config.cellRadius; offsetX++)
  {
    for (int offsetY = -config.cellRadius; offsetY <= config.cellRadius; offsetY++)
    {
      if (!grid.TryGetCell(x + offsetX, y + offsetY, out var cell))
      continue;
      foreach (int targetIndex in cell)
      {
        Vector2 displacement = source.position - targets[targetIndex].position;
        float distanceSquared = displacement.sqrMagnitude;
        if (distanceSquared < config.minDistSq || distanceSquared > config.maxDistSq)
          continue;
      
  float distance = Mathf.Sqrt(distanceSquared);
      if (distance < 0.0001f)
        continue;
      float normalized = config.inverseRange > 0f ? (distance - config.minDist) * config.inverseRange : 0f;
      float curveValue = config.sampler.Evaluate(normalized);
      force += (displacement / distance) * (curveValue * forceScaler);
      }
    }
  }
  
 return force;
}

Private Vector2 CalculateForce(Particle source, SpatialGrid grid, Particle[] targets, InteractionConfig config)
  if (source == null || grid == null || targets == null || config.maxDist <= config.minDist)
    return Vector2.zero;
  
  grid.GetCell(source.position, out int x, out int y);
  Vector2 force = Vector2.zero;
  for (int offsetX = -config.cellRadius; offsetX <= config.cellRadius; offsetX++)
  {
    for (int offsetY = -config.cellRadius; offsetY <= config.cellRadius; offsetY++)
    {
      if (!grid.TryGetCell(x + offsetX, y + offsetY, out var cell))
      continue;
      foreach (int targetIndex in cell)
      {
        Vector2 displacement = source.position - targets[targetIndex].position;
        float distanceSquared = displacement.sqrMagnitude;
        if (distanceSquared < config.minDistSq || distanceSquared > config.maxDistSq)
          continue;
      
  float distance = Mathf.Sqrt(distanceSquared);
      if (distance < 0.0001f)
        continue;
      float normalized = config.inverseRange > 0f ? (distance - config.minDist) * config.inverseRange : 0f;
      float curveValue = config.sampler.Evaluate(normalized);
      force += (displacement / distance) * (curveValue * forceScaler);
      }
    }
  }
  
 return force;
}


Why you see those patterns


Why you see those patterns
Every ordered pair (A->B, B->A, etc.) contributes a term to a coupled-looking differential system:
F₁ = Σ ((source − target).normalized × curve((|d| − min)/range) × forceScaler)

The direction comes from the normalized displacement, while the magnitude comes from whatever curve you provided, positive values attract, negative repel. Smooth curves produce soft clustering; sharp peaks trigger energetic oscillations and shells. Opposing curves create orbiting equilibria around their zero crossings. Because all curves and ranges are randomized on startup, the system behaves like a live experiment in emergent particle art every time.

What to expect

Visual output varies run-to-run, but common motifs are:

• Swirling filaments where one family chases another.
• Drifting, layered shells where attraction balances repulsion.
• Momentary clumps that form, burst, and reform as the curves fluctuate.

The damping parameter keeps the kinetic energy in check, and the spatial grid keeps the update loop fast even with thousands of particles.

using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using UnityEngine.SceneManagement;

public class AsyncLoadScene : MonoBehaviour
{
    public Image bar;
    private AsyncOperation asyncOperation = null;

    void Start()
    {
        bar.fillAmount = 0f;
        StartCoroutine(LoadScene());
    }

    IEnumerator LoadScene()
    {
        yield return asyncOperation = SceneManager.LoadSceneAsync("Main");
    }

    void Update()
    {
        if (asyncOperation != null)
            bar.fillAmount = asyncOperation.progress;
    }
}

using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using UnityEngine.SceneManagement;

public class AsyncLoadScene : MonoBehaviour
{
    public Image bar;
    private AsyncOperation asyncOperation = null;

    void Start()
    {
        bar.fillAmount = 0f;
        StartCoroutine(LoadScene());
    }

    IEnumerator LoadScene()
    {
        yield return asyncOperation = SceneManager.LoadSceneAsync("Main");
    }

    void Update()
    {
        if (asyncOperation != null)
            bar.fillAmount = asyncOperation.progress;
    }
}

How it works:

• It uses SceneManager.LoadSceneAsync to load a scene called “Main” without freezing the game.
• A UI.Image (used as a fillable bar) visually displays the progress via asyncOperation.progress.

Note:

This is just a test/demo to show how asynchronous scene loading works in Unity. In a production setup, you would never hardcode the name of the scene. Instead, you’d pass it dynamically, via a variable, a game manager, or a menu system.

To test:

Just assign the bar in the inspector, and this script handles the rest.

Once I stepped back, I realized I had actually enjoyed the process more than I thought. I remembered how much I love building systems, experimenting with mechanics, and watching things come to life on the screen. That feeling reminded me why I started making games in the first place.

I have had this idea floating around for a clicker or idle game, something simple but satisfying. After not doing any real game development for about two years, I finally feel like I have a concept worth pursuing. Right now I am building a small proof of concept to test the core loop, to see if it is as fun as it seems in my head or if it falls flat.

This will not be a short project. My time for game development is limited, and I am not expecting to finish in a few months. But hopefully it will not take years either. If the prototype feels right, I might actually plan things out properly this time and aim for a Steam release. That would be a first for me.

I am a programmer at heart, not an artist or composer, so I will probably look for help when it comes to visuals, sound effects, and music. I can make placeholder art, but it is not something anyone would want to look at for long.

So, long story short, I have a new project for the first time in two years, and it feels good. I do not know where it will go yet, but for the first time in a long while, I am genuinely excited to find out.

const in C++ is a promise. Use it on parameters or functions to say, “I’m not changing this.” It makes your intent clear, prevents accidental changes, and improves code readability.

There are two main ways you can use const:

1. const Parameters

If you have a parameter that you don’t intend to modify, mark it as const.

void process(const std::string& text);

void process(const std::string& text);

Here, text is read-only. If you try to modify it, the compiler will stop you. This is especially useful for references and pointers, where you could otherwise accidentally change the original object.

2. const Member Functions

When you add const to the end of a member function, you’re telling the compiler that this function won’t change the object’s state.

class Example {
public:
int getValue() const; // Won’t modify member variables
};

class Example {
public:
int getValue() const; // Won’t modify member variables
};

Inside such a function, this becomes a pointer to a const object, so you can only call other const member functions (unless a member is marked mutable).

3. Combine multiple uses of const

You can make both the parameter and the function itself const:

int compare(const Example& other) const;

int compare(const Example& other) const;

Now neither this nor other can be modified in the function.

Why bother?

• Makes your intent explicit.
• Helps the compiler catch mistakes.
• Makes your API easier to understand.

So this is something I’ll have to keep in mind moving forward with my C++ re-learning journey.

Pop!_OS was outdated and couldn’t handle my new AMD GPU. I tried alternatives like SteamOS, but that failed too. Eventually found CachyOS, an Arch-based, but plug-and-play distro. Now everything works perfectly. If you’re gaming on Linux, I highly recommend it.

A few days ago, I accidentally messed up my computer so badly I couldn’t recover the OS. In my desperation to reinstall, I figured, why not fix a few other things too?

I’ve been gaming on Pop!_OS, but with my new AMD graphics card, it’s been a challenge to get it working. Pop is still stuck on 22.04, with an old kernel, and I had all sorts of issues getting my new AMD graphics card to work.

I eventually got it running by updating to XanMod kernel, manually updating Mesa to 25+ and downloading form firmware files that should be able to better connect the two. And I got it working.. sort of. I could play Dune Awakening, but the game had a hole in the terrain around the player, not ideal when you’re jumping around on cliffs.

So I started looking elsewhere.

I had me eye set on Ubuntu, as I knew that the official AMD driver for my card should be able to be installed without any problems. But when I mentioned it to my CTO friend, he almost chocked on his coffee. He suggested SteamOS. So I tried. But the installer just got stuck at a black screen. Dead end.

Then I stumbled on another distro called CachyOS. Never heard of it before, but figured why not? It’s Arch-based (which I actually had tried before), and it looked to be a fast implementer of new kernels, so why not try. I just want things to work.

I picked the GNOME desktop as that’s what I’m used to, and got CachyOS installed. And everything just worked out of the box. No messing with kernels. No driver downloads. So I installed Steam, launched Dune Awakening, hit “play”, and it ran perfectly, high framerate, and best of all no holes in the sandy floor.

So, if you’re on Linux and having trouble gaming, give CachyOS a try. Or if you are on Windows and had enough of forced updates, endless telemetry, or hardware demand changes.

CachyOS just works. Massive thanks to the contributors and maintainers, you’re doing an amazing job.

Being a programmer is weird. Sometimes you solve tough problems and feel amazing. Other times you spend 8 hours hunting a missing semicolon. You can feel exhausted, yet have nothing concrete to show. It’s a job full of mental gymnastics, and it’s both deeply rewarding and utterly frustrating.

I’ve multiple times been confronted by blue-collar workers who joke that we, programmers, “just sit behind a screen all day not doing nothing.” And I get it. They work hard, physically. But our jobs are hard in a different way.

Programming can be deeply satisfying. On good days, you solve tricky problems, feel productive, and walk away energized. Other days? You stare at the screen for eight hours and the only thing you accomplished was finding the missing semicolon.

It’s also mentally exhausting. Especially when you’re trying to keep good chunk of logic flow in your head, to solve something or just to understand the code, and then you are interrupted by a meeting, a college or an email notification. Then it takes forever to rebuild that mental image again. And sometimes, it’s not only interruptions, sometimes your brain just loses the thread – you’re in the zone, holding five different logical states in your head, nearly at a breakthrough… and then poof, it’s gone. That mental toll is real. I end some days completely drained.

Meanwhile, physical workers come home and collapse on the couch. We do the same, but not because we’ve lifted anything heavier than a coffee mug.

What frustrates me most about working as a software developer, is spending a full day debugging, changing maybe three lines of code, and having nothing that feels tangible to show for it. You look at your commit history:
“fix typo, fix bug, cleanup” — and you’re like, “That’s it?”

And sure, I’ve had great mentors who reminded me that it’s not about how many lines you write, it’s about writing the right ones. I know they’re right. But there’s a difference between knowing, and feeling it.

Some days, I feel like an imposter. Like if someone reviewed my output, they’d go, “Why the hell are we paying this guy?” And yet, I’ve built real things, fixed real bugs, shipped actual features.

First create a .desktop file on your desktop.

nano ~/Desktop/Godot.desktop

nano ~/Desktop/Godot.desktop

Now add the following code, and adjust the location to match your application and icon location. Here I’ve downloaded and copied Godot to Applications in my home directory.

[Desktop Entry]
Type=Application
Name=Godot
Exec=/home/nope/Applications/Godot_v4.4-stable_mono_linux.x86_64
Icon=/home/nope/Applications/GodotIcon.png
Terminal=false

[Desktop Entry]
Type=Application
Name=Godot
Exec=/home/nope/Applications/Godot_v4.4-stable_mono_linux.x86_64
Icon=/home/nope/Applications/GodotIcon.png
Terminal=false

After saving the file, we need to make it executable, to be able to run the application by clicking the icon.

chmod +x ~/Desktop/Godot.desktop

chmod +x ~/Desktop/Godot.desktop

Before you can just start the application by clicking it, you need to right-click the icon and select “Allow Launching”.

That’s it! You can now run the application by simply clicking the icon.

Optional

If you want to add the application to the application menu. You just have to copy the .desktop file to ~/.local/share/applications/ and the application will show up in the application menu.

Here is how to do it;
First create the different config files, one for each folder.

.gitconfig-work

[user]
  email = workEmail@work.com
  name = workName
[core]
  autocrlf = input
[credential]
  helper = store

[user]
  email = workEmail@work.com
  name = workName
[core]
  autocrlf = input
[credential]
  helper = store

.gitconfig-private

[user]
  email = privateEmail@private.com
  name = privateName
[core]
  autocrlf = input
[credential]
  helper = store

[user]
  email = privateEmail@private.com
  name = privateName
[core]
  autocrlf = input
[credential]
  helper = store

And now the .gitconfig

[includeIf "gitdir:~/workFolder/"]
path = ~/.gitconfig-work

[includeIf "gitdir:~/privateFolder/"]
path = ~/.gitconfig-private

[includeIf "gitdir:~/workFolder/"]
path = ~/.gitconfig-work

[includeIf "gitdir:~/privateFolder/"]
path = ~/.gitconfig-private

When you now push to repositories located in privateFolder the name privateName will be used, and for the folder workFolder the name workName is used.

Have you ever wanted to just host your repositories at home instead of handing over everything to some lesser trustworthy third-party site? Then this might be a simple solution for you.

Setup

To create the local hosted git repository.

>cd location_for_the_repository
>git init --bare new_local_hosted_repo.git

This will create a folder ending in .git
Now to use it, navigate to where you want to checkout your working directory

>cd working_directory

and clone the newly created repository

>git clone full_path_to_new_local_hosted_repo.git

The workspace is now ready to use, and you can do all the same things you would normally do, using GitHub, Bitbucket or any other online repository.

A Full example:

>mkdir ~/repositories
>cd ~/repositories
>git init --bare best_game_ever.git
>mkdir ~/workDirectory
>cd ~/workDirectory
>git clone ~/repositories/best_game_ever.git
>cd best_game_ever
>touch ./note.txt
>git add *
>git commit -m "initial commit"
>git push

Note: Remember to backup ~/repositories

L-systems were introduced and developed by Aristid Lindenmayer back in 1968 and are often used to produce fractals or images of flowers, as the repeating nature of some flowers is very easy to reproduce using L-systems. L-systems consist of four parts: variables, constants, Axiom, and rules. The rules describe how the axiom, or start expression, evolves from iteration to iteration.

Let’s look at a classical example:

• Variables: L
• Constants: +, −
• Axiom: L
• Rules: L => L-L++L-L

How the different symbols are interpreted is entirely up to us, but in this example, we define:

• L to mean “draw line forward”
• + to mean “turn left”
• − to mean “turn right”

So the algorithm is a simple search and replace. We go through the axiom or start string L and replace it according to the rule, resulting in the following strings:

• Iteration 1: L => L-L++L-L
• Iteration 2: L-L++L-L => L-L++L-L-L-L++L-L++L-L++L-L-L-L++L-L
• Iteration 3: L-L++L-L-L-L++L-L++L-L++L-L-L-L++L-L => L-L++L-L-L-L++L-L++L-L++L-L-L-L …

and we can keep going for as many iterations as we like, but as we can already see, the resulting string grows very raptly because of the “long” rule for L. If the rule for L was simpler, the resulting string of cause wouldn’t grow as fast.

Repeatedly applying the rules increases structure and complexity.

But enough theory; If you want more information, you can read an in-depth explanation of L-systems on Wikipedia.

Implementing the L-system.

We’ll be use strings for variables, constants, and axiom, a StringBuilder for building up the result, and a simple Map<string, string> for the rule(s), defining the string to search for and what to replace it with.

First we define the RuleSet:

@Serializable
data class RuleSet(val rules: Map<String, String>, val axiom: String)

@Serializable
data class RuleSet(val rules: Map<String, String>, val axiom: String)

As simple as can be, simple data class containing the axiom and the Map containing the rules.
We need the annotation @Serializable as we will be reading the rules from a JSON file.

{
  "rules": {
    "L": "L-L++L-L"
  },
  "axiom": "L"
}

{
  "rules": {
    "L": "L-L++L-L"
  },
  "axiom": "L"
}

This is the simple rule for creating the image displayed above.

The simple constructor for the LSystem class is only taking a RuleSet as parameter:

class LSystem(private val ruleSet: RuleSet)

class LSystem(private val ruleSet: RuleSet)

The generate function takes in the number of iterations to run and calls the generateExpression that number of time. It also times how long each generation takes in nanoseconds.

fun generate(iterations: Int) {
    expression.append(ruleSet.axiom)
    
    var startTime: Long
    var endTime: Long
    
    for (i in 0 until iterations) {
        startTime = System.nanoTime()
        expression = generateExpression(expression)
    
        endTime = System.nanoTime()
        println("Time to generate iteration ${i + 1}${endTime-startTime}ns - With a size of ${expression.length}")
    }
}

fun generate(iterations: Int) {
    expression.append(ruleSet.axiom)
    
    var startTime: Long
    var endTime: Long
    
    for (i in 0 until iterations) {
        startTime = System.nanoTime()
        expression = generateExpression(expression)
    
        endTime = System.nanoTime()
        println("Time to generate iteration ${i + 1}${endTime-startTime}ns - With a size of ${expression.length}")
    }
}

The generateExpression function is the heart of the L-System. It goes through the current expression character by character and tries to match up the rules with the upcoming characters using the matchesPattern helper function. When a match is found, the resulting string from the rule is appended to the new expression. If no match is found, the current character is appended to the new expression. This approach avoids the need for rules that don’t replace anything, such as “-” => “-“.

private fun generateExpression(expression: StringBuilder) : StringBuilder {
    val newExpression = StringBuilder()
    
    var position = 0
    while (position < expression.length) {
        var matched = false
    
        // Check each pattern in order
        for (pattern in ruleSet.rules) {
            if (position + pattern.key.length <= expression.length && // check we are not matching outside the expression
                matchesPattern(this.expression, position, pattern.key)
            ) {
                matched = true
                position += pattern.key.length // Move the position forward after matching
                newExpression.append(ruleSet.rules[pattern.key])
                break
            }
        }
    
        if (!matched) {
            newExpression.append(expression[position])
            position++ // Move to the next position if no pattern matched
        }
    }
    
    return newExpression
}

private fun generateExpression(expression: StringBuilder) : StringBuilder {
    val newExpression = StringBuilder()
    
    var position = 0
    while (position < expression.length) {
        var matched = false
    
        // Check each pattern in order
        for (pattern in ruleSet.rules) {
            if (position + pattern.key.length <= expression.length && // check we are not matching outside the expression
                matchesPattern(this.expression, position, pattern.key)
            ) {
                matched = true
                position += pattern.key.length // Move the position forward after matching
                newExpression.append(ruleSet.rules[pattern.key])
                break
            }
        }
    
        if (!matched) {
            newExpression.append(expression[position])
            position++ // Move to the next position if no pattern matched
        }
    }
    
    return newExpression
}

The helper function matchesPattern goes through the characters in the pattern and tries to match them with the next characters in the input StringBuilder. This is a greedy approach, so the order of the rules matters. For instance, if we have the two rules “-” => “L” and “–” => “L” in that order, the second rule will never be applied because the first rule always matches first. Therefore, place the longer rules first.

We could pre-sort the rules, but for this introduction, we just have to keep the order in mind.

  private fun matchesPattern(input: StringBuilder, position: Int, pattern: String): Boolean {
    for (index in pattern.indices) {
        if (input[position + index] != pattern[index]) {
            return false // Return false if any character doesn't match
        }
    }
    
    return true // Return true if all characters match
}

  private fun matchesPattern(input: StringBuilder, position: Int, pattern: String): Boolean {
    for (index in pattern.indices) {
        if (input[position + index] != pattern[index]) {
            return false // Return false if any character doesn't match
        }
    }
    
    return true // Return true if all characters match
}

Implementing the Visualizer

So now we have a long string of characters, but we need to interpret in some way. This is where the visualizer comes in.
We started by defining the variables and constants –, +, and L, so now we just have to draw from the expression.

The Visualizer constructor takes a few parameters:

• expression, the expression to be interpreted
• imageSize, the size for the output image
• padding, the padding around the figure to the edge of the image, in pixels
• filename, the filename for the output file.

class Visualizer(
    private val expression: StringBuilder,
    private val imageSize: Vector2,
    private var padding: Float,
    private var filename: String
) 

class Visualizer(
    private val expression: StringBuilder,
    private val imageSize: Vector2,
    private var padding: Float,
    private var filename: String
) 

Let’s start with the rules and the drawing function doTurtleAction. But for that to make sense, we’ll also have to look at the SystemState data class.

data class SystemState(
    var position: Vector2,
    var angle: Float,
    var length: Float,
)

fun doTurtleAction(c: Char, state: SystemState, canvas: Canvas? = null, draw : Boolean = true) {
    when (c) {
        'L' -> drawLine(state, canvas, aPen, draw)
        '+' -> state.angle += 45
        '-' -> state.angle -= 45
    }
}

data class SystemState(
    var position: Vector2,
    var angle: Float,
    var length: Float,
)

fun doTurtleAction(c: Char, state: SystemState, canvas: Canvas? = null, draw : Boolean = true) {
    when (c) {
        'L' -> drawLine(state, canvas, aPen, draw)
        '+' -> state.angle += 45
        '-' -> state.angle -= 45
    }
}

The SystemState class keeps track of the current position of the pen drawing the figure, the current angle in degrees, and the length. This can be extended to keep a stack of positions that can be pushed and popped so that when drawing, it can store a position, draw something, and return to that position. However, this isn’t implemented in this simple version.

In doTurtleAction, using Kotlin’s when function makes interpreting the character very straightforward. Here, we define what we want the different variables and constants to do. We use 45 degrees for + and – because this will create a nice Koch fractal, but you can set it to whatever you like. L draws a line based on the length and angle in state.

I added some extra steps in the Visualizer to help always output a nice image of the whole figure. That is, I go through the entire algorithm without drawing anything; I only log the minimum and maximum positions. This allows me to scale the lines to draw and set the starting position so the figure is centered and fills the given image size, excluding the padding.

Calculating the area of the figure with the line at size 1 is done using the calcArea function.

private fun calcArea(): Rectangle {
    val state = SystemState(
        angle = 0f,
        length = 1f,
        position = Vector2(0f, 0f)
    ) hosted 
    
    expression.toString().forEach { c ->
        doTurtleAction(c, state, null,false)
        updateAreaData(state)
    }
    
    val x = floor(minXPosition)
    val y = floor(minYPosition)
    val w = ceil(maxXPosition) - x
    val h = ceil(maxYPosition) - y
    return Rectangle(x.toInt(), y.toInt(), w.toInt(), h.toInt())
}

private fun calcArea(): Rectangle {
    val state = SystemState(
        angle = 0f,
        length = 1f,
        position = Vector2(0f, 0f)
    ) hosted 
    
    expression.toString().forEach { c ->
        doTurtleAction(c, state, null,false)
        updateAreaData(state)
    }
    
    val x = floor(minXPosition)
    val y = floor(minYPosition)
    val w = ceil(maxXPosition) - x
    val h = ceil(maxYPosition) - y
    return Rectangle(x.toInt(), y.toInt(), w.toInt(), h.toInt())
}

When outputting the image, we start by getting the area and performing some calculations to get the scale and the starting point to use.

private fun outputAsImage(maxImageSize: Vector2, filename: String) {
    val area = calcArea()
     
    val xScale = (maxImageSize.x - padding) / area.width
    val yScale = (maxImageSize.y - padding) / area.height
    val scale = if (xScale < yScale) xScale else yScale
    
    val state = SystemState(
        angle = 0f,
        length = scale,
        posi hosted tion = Vector2(minXPosition * (-scale) + (padding / 2), minYPosition * (-scale) + (padding / 2))
    )

private fun outputAsImage(maxImageSize: Vector2, filename: String) {
    val area = calcArea()
     
    val xScale = (maxImageSize.x - padding) / area.width
    val yScale = (maxImageSize.y - padding) / area.height
    val scale = if (xScale < yScale) xScale else yScale
    
    val state = SystemState(
        angle = 0f,
        length = scale,
        posi hosted tion = Vector2(minXPosition * (-scale) + (padding / 2), minYPosition * (-scale) + (padding / 2))
    )

Now we setup the canvas to draw on. Here we use the Kotlin wrapper for the Skia 2d graphics library called skiko.

    val surface = Surface.makeRaster(ImageInfo.makeN32(maxImageSize.x.toInt(), maxImageSize.y.toInt(), ColorAlphaType.OPAQUE))
    
    // Get the canvas from the surface
    val canvas = surface.canvas
    // Clear the canvas with a white background
    canvas.clear(Color.TRANSPARENT)

    val surface = Surface.makeRaster(ImageInfo.makeN32(maxImageSize.x.toInt(), maxImageSize.y.toInt(), ColorAlphaType.OPAQUE))
    
    // Get the canvas from the surface
    val canvas = surface.canvas
    // Clear the canvas with a white background
    canvas.clear(Color.TRANSPARENT)

Note: The Kotlin wrapper for Skia doesn’t use the same naming for classes and functions, which makes it challenging to use the documentation for Skia. After a lot of searching, I got it working, but without a deeper understanding of why, so I’m not sure if it’s the right way of using it. But it works.

Now we draw the figure and output the image to a file.

    expression.toString().forEach { c -> doTurtleAction(c, state, canvas) }
    
    // Get the snapshot of the surface
    val image = surface.makeImageSnapshot()
    
    // Encode the image as a PNG
    val data = image.encodeToData(EncodedImageFormat.PNG, 100)
    
    // Save the PNG to a file
    File("$filename.png").writeBytes(data!!.bytes)
}

    expression.toString().forEach { c -> doTurtleAction(c, state, canvas) }
    
    // Get the snapshot of the surface
    val image = surface.makeImageSnapshot()
    
    // Encode the image as a PNG
    val data = image.encodeToData(EncodedImageFormat.PNG, 100)
    
    // Save the PNG to a file
    File("$filename.png").writeBytes(data!!.bytes)
}

That’s it!
I’ve added the full project code here, for free download.

Thoughts:

However, nothing says we must use repetitive rules; we can do whatever we want. We could alternate between differenthosted rules, shift rules when a specific pattern is seen, reverse parts based on other triggers, or use any approach that could yield an interesting result. I like to add randomness to the constants, so instead of turning exactly 90 degrees, we turn 90 degrees plus or minus some small random value to introduce variation. Create different weighted rules, allowing multiple rules for the same pattern with different probabilities! “Barney Codes” has already implemented this, as seen in YouTube video.