Seven hours later I had something that kind of moved pieces around — a tiny Python console program that could draw a board and accept moves. Nothing fancy. No UI. No clocks. Barely any rules. But it was mine, and it worked enough to be fun.

Then another friend said the sentence that doomed my free time:

“Okay… but what if this was a World of Warcraft addon?”

And that idea was too good to ignore. So I started over — different language, different constraints, different everything. The result is DeltaChess: chess inside WoW, against other players (including cross‑realm where WoW allows) or against the computer.

If you want to peek at it later: CurseForge / GitHub

Chess in a place that really doesn’t want chess

Writing chess code is one thing. Writing chess code in the WoW Lua sandbox is another.

In Python on the console, “just compute for a bit longer” is an acceptable strategy. In WoW, it’s a great way to make the game hitch and drop frames. So the project quickly became about constraints:

• Rules correctness: castling, en passant, promotion, draw rules… the boring parts that make it “real chess”.
• Responsiveness: engines must yield work so the game keeps rendering smoothly.
• Determinism and safety: don’t crash your UI because an engine tried something illegal.

Here’s what the board looks like today:

And the “play vs computer” flow that wires the UI into the engine framework:

PGN export was a must-have (because what’s the point of blundering in WoW if you can’t paste it into Lichess later?):

The part I didn’t expect: I actually learned chess programming

I used a fair amount of AI assistance for UI and addon glue code, but the engine side pulled me into the classic chess programming rabbit hole: search, evaluation tradeoffs, move generation pitfalls, and performance tricks you only learn once you can feel the branching factor.

Some highlights of what I ended up (re-)learning:

• UCI (Universal Chess Interface): the lingua franca for “engine talks to GUI”. I built a small UCI wrapper so I could run and test the Lua engines from the outside world (and compare behaviors).
• Minimax → Negamax: switching from “two-player min/max” to “one function + sign flip” is one of those “why didn’t I do this earlier?” moments.
• Alpha–Beta pruning: the first time you watch node counts collapse because your move ordering improved, it’s addictive.

And on a purely personal level: it was a nice excuse to refresh my Lua knowledge (including the parts you only remember once you write something non-trivial and performance-sensitive).

A pluggable, async engine framework (because WoW demands it)

DeltaChess ships with a small engine framework that tries to make the hard parts boring:

• Engines are stateless: each calculation gets a position + options; no hidden global state required.
• The runner is single-threaded and async: engines can yield via a callback so computations spread across frames.
• Every move is validated: if an engine returns an illegal move, it’s caught immediately.

The real reason the framework exists: testing outside of WoW

One of the biggest practical problems early on wasn’t even search or evaluation — it was testing.

Inside WoW I couldn’t easily run automated tests that would tell me whether an engine always produces legal moves, and whether the move generator behaves consistently across thousands of positions. Debugging that kind of thing by hand, in a UI, is misery.

So I extracted the whole “business logic” (rules + move generation) and the engines into a separate project that can run completely outside the WoW environment. That gave me a proper automated test suite where engines can self-play and every returned move is validated for legality.

The framework also supports ELO-based difficulty selection and ships with four engines spanning roughly beginner to very strong:

Huge thanks to Chessforeva and their Lua chess work, especially the Lua4chess repository. They had already ported several classic engines to Lua, which made them way easier to integrate.

There was one catch though: those ports were written in a more “normal” style where you just… calculate until you’re done. In WoW’s single-threaded UI, that meant the game could hang for several seconds whenever an engine thought too long.

So a big chunk of the project ended up being rewriting/adapting the engines to allow async execution in an event loop: do some work, yield, resume next frame, repeat — so the game stays responsive while the engine is searching.

If you’re curious, the engine framework lives here: deltachess-engine-framework

Where I’m stuck: ELO calibration for slow Lua engines

This is the part where I’d love advice from people who have done this “for real”.

The engines are written in Lua (because WoW), so they’re slow compared to typical C/C++ engines. I tried running tournaments via cutechess, but getting anything remotely stable takes an absurd amount of time.

My goal isn’t perfect scientific accuracy—I just want players to pick an AI opponent that roughly matches their strength, instead of random “difficulty” labels.

So if you have experience with engine testing and rating, I’d appreciate any pointers:

• Are there smarter ways to estimate / approximate ELO for slow engines without weeks of round-robin games?
• Any good approaches for calibrating across very different environments (fast desktop vs WoW sandbox)?
• Any tricks for cutting down match counts without totally ruining the numbers (SPR T-tests, sequential testing, smarter opponent selection, etc.)?

If you try DeltaChess, skim the code, or have “don’t do this, it’s a bad idea” comments—please let me know. This was never meant to be a serious engine project, but it definitely pushed me down the rabbit hole, and I’d love to learn more.

The so‑called “firewall” against the AfD cannibalizes itself through an involuntary “marriage” of partners who have hardly anything in common—until it eventually breaks. Unfortunately, that reminds me of 1939.

Rejection of Migration: Causes and Consequences

We have to accept—and acknowledge—that people in Germany no longer want immigration. There are various reasons for this: the country being overwhelmed by more than 2.5 million refugees over the last ten years, the emergence of parallel societies, and the erosion of people’s sense of fairness and justice.

Political Failure and the Erosion of Fairness

That this sense of fairness has eroded is the responsibility of the political actors of recent years. Under the grand coalitions, action against precarious employment conditions happened only in “homeopathic” steps for a long time. Meaningful improvements for those who have the least are not broadly supported, because the working middle feels overburdened—by inflation, the heating law, and the threat of job loss. The impression is spreading that work no longer pays off in this country.

Bureaucracy and Hostility Toward Business as a Brake on Growth

Businesses get stones thrown in their way instead of tailwinds, and every year they’re burdened with even more bureaucracy. Anyone who wants to build a new production hall should beware: if you’re not Intel or Elon Musk, you have to wrestle with pointless rules and excessive regulations on fire safety, energy retrofits, archaeology, and more. This snail’s pace is only surpassed by government projects. Today we build bridges at a speed at which entire neighborhoods used to be constructed. We need a clear‑cutting of our jungle of laws and regulations, and a massive slimming‑down of bureaucracy.

The Danger of Simple Solutions—and the Way Forward

The “simple solution” promoted by right‑wing parties is to kick downward. That may briefly satisfy an enraged middle, but it endangers social peace. The solution must be to improve conditions in the low‑wage sector and for the middle of society—for example by raising the minimum wage.

Loss of Trust in Governing Parties

In the face of all these problems, it currently feels like almost all parties are closing their eyes. People have simply lost trust that the governing parties of the last decades are capable of solving these issues.

So What Now?

Germany stands at a crossroads, and radical measures are required immediately. The paralyzing mills of bureaucracy must be dismantled without further delay. Laws must be streamlined to remove the bureaucratic superstructure that hinders business and innovation. Penalties for violent crimes must be tightened drastically, and we need more funding and staff for our police to guarantee public safety without curtailing civil liberties.

A stepwise increase of the minimum wage is urgently needed to restore social justice and economic fairness. Necessary innovations to protect our planet must be accelerated through significantly higher CO₂ taxation. This will only be accepted if every cent is paid back out as a climate dividend (energy money), with additional support for lower‑income groups.

On migration policy, immediate action is required: asylum procedures must not take longer than a few months, and taking up work in skilled trades and healthcare must be enabled right away. At the same time, consistent measures must be taken against rejected asylum seekers if they reject our societal values—this includes consistent deportations, so that those who truly enrich our society, or who genuinely need our protection, can stay.

It’s high time we implement these necessary reforms. Germany can’t afford to keep hesitating.

What I did not manage to get running was adding a cluster in Rancher using LXC nodes. I left the topic aside and moved on to other things. I had a lot of other projects in the meantime with Rachner and Kubernetes in general, and now wanted to finally start using it for my own infrastructure.

Sure I could have accepted that Kubernetes is not running in LXC and used KVM based nodes to run a cluster. But I did not. There must be a way. Others are running Kubernetes as well in LXC containers. And resource usage, as well as backup is so much more efficient when using LXC containers.

No final success (yet)

Before you expect to find the final solution in this blog post, I must disappoint you. I have solved a few problems so far but still did not manage to bring up a final cluster (yet). If you have any ideas after reading this, how to get it done, please let me know.

The problem I was facing at the end is, that I was stuck at the error “network plugin is not ready: cni config uninitialized”.

The reason for the problems

The main difference between KVM and LXC is that containers are sharing the kernel with the host. Also there is no virtualization of devices. It behaves more like an advanced chroot. This means access to /proc, /sys and /dev is limited. Additionally the container lacks a lot of kernel capabilities by default. Loading of kernel modules cannot be done inside of the container, but rather needs to be done on the host.

Docker requirements

Ranchers RKE1 (which is still the only available stable version as of the date of this post), is still using docker as container runtime, even though this has been deprecated by the Kubernetes project. But as this is still the case, we need to meat the docker requirements first, in order to proceed to the next step.

Docker requires a few kernel modules to be enabled. Those are overlayfs and aufs. We will see some other required kernel modules later on as well, but lets keep it to those for now. Docker normally would load the modules for us, but as this is not permitted within the LXC container, we need to do it ourself.

Executing following commands should do the trick.

modprobe aufs
modprobe overlay

To ensure they are loaded on boot of the system the cleanest way is to create a file in /etc/modules-load.d.

cat > /etc/modules-load.d/docker.conf <<EOF
aufs
overlay
EOF

Now let’s create a container on the proxmox host. In my case it has the id 100, is using Ubuntu 20.04 as base image, has mgmt1.n.dev.localhost as hostname. Make sure to adjust the network configuration to your network.

pct create 100 local:vztmpl/ubuntu-20.04-standard_20.04-1_amd64.tar.gz --cores 4 --memory 4096 --swap 2048 --hostname mgmt1.n.dev.localhost --rootfs local:20 --net0 name=eth0,ip=192.168.0.100/24,bridge=vmbr10,gw=192.168.0.1 --onboot 1

In order to run docker inside of the container, the container needs to be privileged. This is the case, if you don’t especially create the containers as unprivileged in Proxmox. This alone does not give us enough permissions, we need to enable the nesting feature in LXC as well.

pct set 100 --features nesting=1

Now we should be able to start the container, enter it, install docker and run a hello-world container.

As we don’t want the container to be accessible using ssh and only use it as docker host, we remove some unnecessary packages. Please note that the removal of apparmor is required as well.

pct start 100
pct enter 100
apt-get -y remove openssh-server postfix accountsservice networkd-dispatcher rsyslog cron dbus apparmor
wget -O - https://releases.rancher.com/install-docker/20.10.sh | sh
reboot

Please note that we install docker using the script provided by Rancher, to have be compatible with the Kubernetes version we want to install. Feel free to check the script before you just dump it into sh. If you don’t want to use Kubernetes you can also install the docker.io package from distribution repositories.

Now docker run hello-world should give you:

root@mgmt1:~# docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
2db29710123e: Pull complete 
Digest: sha256:4c5f3db4f8a54eb1e017c385f683a2de6e06f75be442dc32698c9bbe6c861edd
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Running docker containers is not enough

At some point in the rancher setup, after you have created a cluster and want to add nodes to it, you are asked to execute something like this on the node, to bootstrap the cluster.

docker run -d --privileged --restart=unless-stopped --net=host -v /etc/kubernetes:/etc/kubernetes -v /var/run:/var/run  rancher/rancher-agent:v2.6.3 --server https://rancher.localhost --token <some token> --etcd --controlplane --worker

This basically creates a new container running rancher-agent, giving it full access to the docker daemon by mounting /var/run/docker.sock. This lets rancher-agent start new containers with the Kubernetes processes on the node.

Normally you would now grab a coffee and wait 10 to 15 minutes for the node to become alive. But it’s not time for coffee yet.

You will notice that the bootstrapping of the cluster now would fail. The LXC container need more capabilities, and permissions and modules.

I did some research on the internet and adding a few lines to the LXC config, and a few modules should do the trick.

modprobe ip_vs
modprobe ip_vs_rr
modprobe ip_vs_wrr
modprobe ip_vs_sh
modprobe nf_conntrack
modprobe br_netfilter
modprobe rbd
cat >> /etc/pve/lxc/100.conf <<EOF
lxc.apparmor.profile: unconfined
lxc.cgroup.devices.allow: a
lxc.cap.drop: 
lxc.mount.auto: "proc:rw sys:rw"
EOF
cat >> /etc/modules-load.d/docker.conf <<EOF
ip_vs
ip_vs_rr
ip_vs_wrr
ip_vs_sh
nf_conntrack
br_netfilter
rbd
EOF
pct stop 100
pct start 100

Now bootstraping fails because / is not shared. Ok the quick fix is to run mount --make-rshared / in the container.

But still, bootstrapping the node gives me some error like [controlPlane] Failed to upgrade Control Plane: [[host mgmt1 not ready]].

After running docker ps on the node, I noticed on container in state restarting. Looking into the logs of this container, we notice that it did not start because /dev/kmsg is not available.

The problem seems familiar, as it was the same problem we had wen running Rancher in LXC. So I tried the same fix, we did there.

lxc.mount.entry: /dev/kmsg dev/kmsg none defaults,bind,create=file

Problem seems that now /dev/kmsg exists, but is not readable. I did not managed to solve this problem, but found a workaround that seems to be sufficient. Linking /dev/kmsg to /dev/console.

So now lets make those changes persistent. Applying those changes on boot using rc.local is not pretty, but should do the job.

cat > /etc/rc.local <<EOF
#!/bin/sh -e

if [ ! -e /dev/kmsg ]; then
    ln -s /dev/console /dev/kmsg
fi

mount --make-rshared /
EOF
chmod +x /etc/rc.local
/etc/rc.local

Access to sysctl

Even after those changes, we see one container failing. Looking into it, you see that Kubernetes wants to change net.netfilter.nf_conntrack_max, as the value configured by default in Proxmox is too low.

In my case I had to change it to at least 786432. The strange thing is, I thought that using proc:rw sys:rw would allow write access to those settings. But this seems not to be the case. Those need to be changed on the host.

I changed the value and tried again. Long story short, those are the settings that need to be changed:

cat > /etc/sysctl.d/100-docker.conf  <<EOF
net.netfilter.nf_conntrack_max=786432
EOF
cat >> /etc/modules-load.d/docker.conf <<EOF
options nf_conntrack hashsize=196608
EOF

Networking problems

After all those changes, in my trys I was stuck at the Problem “network plugin is not ready: cni config uninitialized”. The directory /etc/cni/net.d on the node (which is mapped into the containers), has not been created. I tried all network plugins rancher provided in different versions.

Well, I leave it to this for now.

When rancher is started, it requires to be run in priviliged mode. It determents if has been started in priviliged mode by checking for /dev/kmsg but its never mentioned. So the final soulution is, to not only create a priviliged LXC container, but to also ensure that /dev/kmsg is available in the container, which is not the default.

For this, following entries in the container configuration on Proxmox are required:

lxc.apparmor.profile: unconfined
lxc.cap.drop:
lxc.cgroup.devices.allow: a
lxc.mount.auto: proc:rw sys:rw
lxc.mount.entry: /dev/kmsg dev/kmsg none defaults,bind,create=file

After you created a priviliged LXC container and added the configuration you can install docker and run rancher inside the container.

There is a medium that, out of helplessness, crawls behind paywalls into a digital depression cave—and yet reports seriously and reliably (even if with varying emphasis). At least it still puts different perspectives side by side—just when we need that the most. It’s called the “daily newspaper.”

Visiting the Digital Depression Cave

Because I like to know different viewpoints on a topic, I follow a range of media outlets. That’s why the Deutschlandfunk program “Presseschau” is part of my daily routine. From taz to Handelsblatt, Süddeutsche, FAZ, and WELT—there are worlds between them in how they interpret day‑to‑day politics. And as so often, the truth isn’t black or white, but somewhere in between.

Maybe comparing culture-section pieces is less interesting than comparing front pages. So: buy an entire newspaper just for that? In the analog paper world, hardly anyone does. But digitalization could give publishers the chance to win over regular readers of other newspapers, too.

But instead of shared apps, simple microtransactions, and affordable subscription models, newspapers hide behind paywalls—and wait for death by being forgotten.

This kind of fragmentation is completely outdated in the age of Netflix—especially with prices of €20–€50 per month for a single newspaper. Instead of pooling resources for a truly good app, every publisher reinvents the wheel.

An Angry Letter

All of this annoyed me so much today that I sent the following angry email to the “Bundesverband Deutscher Zeitungsverleger e.V.” (Federal Association of German Newspaper Publishers).

Hello,

in times of digitalization and shrinking circulation numbers, I wonder why German newspaper publishers still haven’t been able to agree on a joint digital offering at an affordable monthly subscription price.

If Netflix can provide access to thousands of series and films for €10 a month, why can’t German newspaper publishers offer access to many newspaper articles for €10 a month—instead of trying to win subscribers with absurd subscription prices of €50 a month?

Hiding the online offering behind paywalls achieves nothing. As a reader, I’m not willing to take out a digital subscription for an article from the “Buxtehude Remscheider Anzeiger” just because that paper happens to show up once a year in my Twitter timeline and the article looks interesting. And no, as a user I’m also not willing to click through five different pages, dig out my credit card or PayPal details, and approve a microtransaction just to unlock a single article. Then I simply won’t read it—or the person who linked it on social media will post a screenshot after 50 comments like “Paywall, can’t read it” roll in. The publisher gains nothing from that. Oh right, I forgot—there’s VG Wort for that 😂.

As part of the digital generation, I can promise you one thing: this is how journalism in Germany will die. Not because the “digital generation” isn’t willing to pay for journalism, but because publishers haven’t understood how digital business models work.

Best regards, Maximilian Ruta

If I receive a reply, I’ll publish it here as well.

Globuli (Homeopathy)

It’s important not to just attack each other, but to be able to put yourself in the other side’s position. I can absolutely understand authors and creators whose works are used constantly without proper compensation. But this reform won’t solve that problem either. I believe we’re ultimately fighting for the same thing: fair compensation for creators. The debate should focus on how to do this better than Article 13 proposes—instead of defending a placebo.

That’s what the EPP group and Mr. Voss in particular are doing. They claim the reform will strengthen creators and seem to believe in it as firmly as some people believe in homeopathy. In fact, there are some parallels.

Just like in homeopathy, the idea is to fight “like with like.” YouTube earns money by using third‑party content; in response, new enforceable rights via collecting societies would lead to blanket license agreements. Because those licenses are flat-rate, collecting societies would then also earn money on works whose rights they don’t actually represent. I paid €87.50 to collecting societies simply to be allowed to print contracts in my company and digitize incoming mail.

And just like homeopathy, the directive is effectively powerless. The platforms that currently make lots of money with ads—where clicking “Play” redirects you to the next porn site—platforms that don’t care about youth protection or the existing notice-and-takedown process, will simply ignore the new rules as well.

Finally, this regulation—again like homeopathy—is dangerous: the many small companies that would ultimately have to license upload filters from Google & co. would end up strengthening the big players and weakening the small ones.

An Example

Back to the email I read. I replied (as one should), and I don’t want to withhold that response from anyone:

Bringing the legitimate interests of creators in line with new technical possibilities is always difficult. We believe the currently proposed regulation does not do justice to either side. Since the trilogue compromise unfortunately also removed all meaningful exemptions for small companies, the proposed measures are entirely out of proportion to their consequences for platform operators.

For example, chefkoch.de would have to negotiate with all rights holders (in the world?) to license content that might potentially be uploaded—even though the platform doesn’t really have a copyright‑infringement problem, since it’s about recipes shared by hobby cooks. Alternatively, the platform could of course check all content for potential copyright infringements before publication.

Filters could be used for this. But their development effort is far from trivial—contrary to what is suggested in this FAZ article. Comparing this to Shazam is misleading: pattern recognition is Shazam’s core business, not a response to a regulatory requirement. A company of that size would likely have to license the technology from providers like Google, or it would have to review content manually with significant staffing costs. But even here, the comparison still breaks down.

A filter—whether human or automated—can’t actually judge whether a work infringes third‑party copyrights. It can only compare whether something resembles a known reference. In other words: for a platform to determine that a photo of an apple pie was taken by a different photographer than the person uploading it, the platform would first need to “know” all apple‑pie photos taken by photographers other than the uploader. It should be obvious that this requirement is simply impossible to meet.

Even if it were possible, you still couldn’t judge whether something is incidental inclusion (e.g. §57 UrhG) or a quotation. Consider recording a demonstration where, for a brief moment, you can hear a snippet of a song in the background.

This example shows why the consequences of the current proposal are completely disproportionate. Article 13 would at least have to include real exemptions for companies that aren’t even the primary target of the reform.

How Could It Be Done Better?

But there are completely different proposals for protecting creators. One idea could be to skim platform profits in favor of the creator in a notice‑and‑takedown case. And even though I personally find it irritating to have paid a flat copyright levy for my printer—despite not committing any copyright infringements with it—that might be the kind of compromise that could align the interests of creators with those of users.

Imagine if we had held manufacturers of scanners, tape recorders, cameras, computers, or printing presses liable for copyright infringements committed with their devices. The world would look very different.

And then there’s an industry that keeps producing new scandals: Cum-Ex, aiding tax evasion, worthless shipping funds, opaque products. An industry that has taken on a life of its own—like an accelerant that makes new bubbles form and burst faster and faster. The problem is that our growth-driven economic system depends on an endless supply of new credit.

As consumers, we depend on cashless payments—without them, we lose access to basic necessities like housing, work, and communication. We’ve gotten used to withdrawing cash for free almost anywhere, getting free credit cards, and paying nothing for a checking account. Some banks even pay you to open an account. We feel courted—and assume banks must be doing great business with our accounts. We assume they “speculate” with our checking balances (more accurately: demand deposits / sight deposits) and therefore must be making enormous profits that fund all these “free” services. But all of these services obviously cost money.

That’s not actually true. In reality, “free” checking accounts are often a loss for banks. Banks can only invest a small portion of the money sitting in checking accounts—but more on that later. Still, the free account is the gateway drug: it’s meant to get us to do more business with the bank where the bank can earn money, such as loans and credit-card turnover, long-term investments, or a securities account.

How Money Works

Money acts like an advance of trust when it flows into a project as a loan or investment. It enables something to be realized and gives it a chance.

That makes credit and investment powerful tools for changing the world. They decide success or failure.

In traditional banking, a bank can essentially only invest and lend money with maturities that match the time horizons on which other customers can demand their money back. That’s why demand deposits aren’t particularly well-suited for lending. Some theories (e.g. the “core deposits” concept) justify deviating from this to a degree, but that’s not the topic here.

On top of that, regulations—such as capital requirements—limit the amount of credit a bank can extend.

So a bank can only provide long-term loans when customers invest money long-term and sufficient equity capital is available.

Why I’m with GLS Bank

We rarely ask what this—our—money actually does in the world when it flows into investments and loans. It almost certainly also finances companies, parties, and organizations whose actions would repel us if we looked closely.

It turns out that money can have a huge impact in changing society for the better. We want it to be used in ways that match our values—so that companies and projects that create deeper meaning receive that advance of trust.

Unfortunately, it’s often hard for these projects and companies to obtain that kind of trust—and the financing that comes with it.

For about two years now, I’ve been a customer and cooperative member of GLS Bank, because it mattered to me that I wouldn’t be advocating for environmental protection, organic agriculture, fair trade, social security, the protection of refugees, and world peace on the one hand—while my money works against those very interests on the other, simply because my bank invests solely for maximum return.

GLS Bank keeps surprising me in a positive way. I’ve come to see that it doesn’t treat “fair banking” (as reviewed by fairfinanceguide.de) as a marketing tool, but actually lives those values.

As a cooperative bank, it belongs to its members and is run democratically. It’s a bank that doesn’t take money from Nazis and that takes a stand with #wirsindmehr.

A bank that stands with tenants in the fight against the world’s real-estate moguls.

A bank that publicly supports people who are fleeing war and hardship (GLS refugee aid).

A bank that is transparent about who gets financed (page 22) and that doesn’t speculate on financial markets.

For money to create real value and meaning, you need to understand when it can be invested long-term.

That doesn’t mean you must act altruistically. Of course, donated money has the longest-lasting effect because it never needs to be repaid—and GLS Bank even offers a way to finance donations. But, for example, buying cooperative shares also creates significant impact: increasing the bank’s equity directly increases the amount of credit it can extend, and members receive an annual dividend.

Given how much good my money can do this way, I’m happy to pay a small fee for my checking account. If this has made you curious about GLS Bank, I recommend listening to the first episode of the GLS podcast, “Who is GLS Bank?”.