There is Python. There is Rust, Go, C, JavaScript and a hundred others. All mature, all built by clever people over many years. A sensible person would have picked one of them and built something with it.
Instead, I built my own. In German. With three different ways of running the code. And I want to explain honestly why — partly because the answer isn't the one you'd expect.
Because as good as the big languages are, there is one thing Kiste does better. One of my testers put it like this: "Finally a language that just runs. One click and everything is set up. One click, and the finished program runs on any other computer. We keep wondering why the others don't do it this way already." Anyone who has ever tried to hand a Python program to someone who isn't a programmer knows exactly what he means. That's not a small convenience. That's the point where the established languages still stumble today — and where Kiste simply works.
The answer nobody wants to hear: because I wanted to
There is no market for a German programming language. There is no company waiting for it. I don't make money from it, and I'm not looking for a thousand users. If you're after a justification along the lines of "this solves problem X for audience Y", I don't have one.
What I do have is a sentence that has stayed with me for years: the journey is the destination.
I build because the building itself is the thing. Not the finished object, not the applause, not the number of downloads. Understanding how something works by putting it together yourself — piece by piece, until it comes alive. For me that isn't a means to an end. It is the end.
Programming in German — why it isn't a gimmick
When I told people that Kiste's keywords are German, it often got a smile. "Cute." But it's the opposite of cute.
Almost every programming language in the world is in English. For millions of people, learning to program therefore means learning two things at once: the logic and the foreign language. A child, a teenager, an adult in a German-speaking country reading if, while, return for the first time doesn't stumble over the logic — that part is easy. They stumble over words that mean nothing to them.
In Kiste, wenn means "if", solange means "while", gib means "give back". The logic stands there bare, with no language barrier in front of it. That isn't playing around. It's an attempt to remove a hurdle that was never really necessary.
Does the world need it? Maybe not. But I found the question too interesting to leave unanswered.
Three backends — and why that was the hard part
This gets technical, but I'll keep it simple. Kiste can run the same code in three different ways: one that reads the code directly, line by line; one that first translates it into a faster intermediate form; and one that builds a real, standalone program from it — a program that runs without Kiste and keeps up with the fastest languages.
Why three? Because each is good at something different — and because they check each other. If all three have to produce the same result for the same code, then every bug stands out immediately: the moment one of them disagrees, I know something is wrong. That rule — three paths, one result — has become the strictest quality control I've ever had.
And honestly: it was simply tempting. The idea that a line of German code reaches the same point along three completely different paths just wouldn't let go of me.
The setbacks that come with it
I don't want to pretend this was a straight road. There were evenings when I cursed Kiste. Bugs that couldn't be found anywhere for hours. Moments when something worked that shouldn't have worked — and that's worse than a clear error, because you don't know why. I built some things three times over. There were points where I doubted whether any of it made sense at all.
But that's exactly part of it. Something you build without resistance, you haven't really built. The resistance is where you understand how something truly works — not the manual, but the bug at two in the morning that you found yourself.
And every time it finally did run, that was a feeling I know no substitute for.
Where all this is heading — my real dream
Now I'll reveal something that is the real engine behind all of it.
I've been a big Minecraft fan for years. And for just as many years I've asked myself: why does it still look like a pile of cubes? Why was it never properly improved? I dream of a game in the spirit of Minecraft — a world that comes into being on its own, that you step into and build in — but beautiful. With rounded shapes instead of just blocks. Furniture that looks like furniture. Graphics that don't hurt to look at, but that you enjoy looking at.
That is exactly what everything is building towards. The language was the first step. Then came a pixel editor for painting the images. Then a graphics engine that moves those images. As I write this, for the first time a hand-drawn spaceship is flying across the screen, controlled by code I wrote in my own language. Each step builds the tool for the next.
The road to that beautiful world is still long. Two-dimensional games first. Then a proper game workshop. At some point the leap into the third dimension. And right at the end, perhaps, the rounded, self-generating world I've been dreaming of for years.
I don't know whether I'll ever make it. It may well be too big, I may run out of time, it may fail. I'm aware of that, and I say it openly.
But I want to at least try. And if the journey is the destination — then I'm already right in the middle of it.
Kiste is a freely available programming language with German syntax and a native compiler. If you'd like to try it, you'll find everything here on kiste-lang.org.