The promise of 5th generation programming language was to formulate AI related problems on a higher abstraction level. Examples like Prolog, Domain specific language and robot control APIs were invented to simplify the programming. Unfurtunately the concept was never accepted in the reality. The reason is, that a programming language is targetted towards the internal behavior of a robot or a computer, and the internal system has no knowledge about the external world.
Let me give an example. Suppose a domain specific language for robot control is invented which consists of statements like:
robot.move()
robot.stop()
robot.chargebattery()
robot.robotpickup()
In theory this DSL sounds logical the problem is to parse such a language with a computer program. A statement like robot.move() can't be converted into low level actions. Its only a mock up without executable programming code. The reason has to do with the difference between internal structure of a system and external environment. The statement "robot.move()" makes only sense if there is a simulation in which the robot can move, rotate and stop. In a normal robot program written from scratch there is no such simulation available, but the memory aka the RAM of a computer program is empty.
Programming language for high level robot control doesn't work, because a programming language is the wrong tool for such a purpose. Programming language like C, Java, Rust or Python are great for technical implementation of ideas but they can't generate artificial intelligence. What is needed is not a programming language but a communication protocol similar to GUI interface. Typical examples for such an interface are the Maniac Mansion verbs shown on the bottom or the vocabulary of a text adventure. These interfaces are not realized as programming language but they are widgets on the screen created for human to machine interaction.
Of course, there is a need to write a computer program which checks if the user is moving the mouse over a verb and presses the button. But such kind of program can be formulated in classical programming language like C/C++ or Python, Because the task for the program is very low level and has to do with recognizing the mouse position and display text on the screen. These tasks have to do with computer programming the core sense because the program defines how to blit pixels to the screen and which sort of game loop is reacting to the user input.
April 15, 2026
The failure of AI related programming language
Closed systems without symbol grounding
Before the advent of human to machine communication there was a different paradigm avaialble which is a closed sytem. A robot was imagined as a self-sufficient system which never receives or submits information to the environment but operates by its own logic realized in software and hardware. Typical questions for such a closed system are:
- how fast is the microcontroller in terms of RAM and Mhz
- which programming languages was used, e.g. Lisp, C/C++
- Is the microcntroller running with 5 Volt or 12 Volt
- how many lines of code has the robot control system
- which mathematical algorithm was implemented in the software
- what is the CPU consumption and the runtime of the algorithm
- is the robot using an inverse kinematics solver
- was a genetic algorithm used
These questions are asked from a classical computer science perspective which includes a mathematical, physical and computer based understanding of robotics. Its about the internal structure of a robot and ignores the environment of the system. Instead of analyzing the task e.g. a warehouse logistics problem or a kitchen cooking problem, the focus is put on the machine itself and their hard- and software.
The main property of a closed system is its inability to communicate with the environment. Its assumed that no information, energy or matter can pass between the robot and the outside world. Possible interaction like teleoperation are ignored or reframed as anti-pattern. For example a typical assumption was, that teleoperation is the opposite of automation and therefor its not needed in robotics.
Even if the robot is working by technical meaning the robot can't solve a certain complex problem because closed systems are only able to manage repeating tasks but fail in more complex applications. Artificial intelligence problems like robot control are exclusively complex task which requires a huge amount of communication from a system with its environment.
April 14, 2026
The success of Artificial Intelligence since 2020
The acceptance of new technology is measured with the user count. In the 1980s expert systems and robotics was available but nobody was using it. These software and hardware was only known in dedicated AI labs.
In contrast large language models available since 2020 are used by large amount of users world wide. Here is a timeline with the estimated number of users:
2020, <1 million
2021, 5 million
2022, 120 million
2023, 500 million
2024, 1200 million
2025, 2100 million
2026, 3500 million
Symbol grounding and the art of communication
For decades from 1950 until 2010 it was an untold bias that Artificial Intelligence gets realized as a closed system. This bias was formulated in an explicit fashion by the artificial life community in the 1990s. A simulated ecosystem gets populated with cellular automata which are evolving by itself into more advanced creates. The goal was, that with more processing power and genetic algorithm it would be possible to create intelligent computer code.
It should be mentioned that all the projects like cellular automaton, self evolving robots and computer simulation have failed. Its not possible to create intelligent structures this way. The reason for this failure wasn't recognized because it has to do with the untold bias of a closed system.
Cellular automaton are imagined as algorithm driven non communicative systems. They are not exchange matter, energy or information with the environment but they exist in a sandbox which acts as a impenetrable wall.
In contrast open system are able to exchange information, energy and matter with the environment. In case of robots this is equal to teleoperation. The robot receives a command from the operator and submits back status information. Such kind of information exchange was missing in artificial life projects and its the reason why the projects are a dead end.
in 1990 the Canadian cognitive scientist Stevan Harnad published a paper in which he introduces the grounding problem. Grounded language is important for communication systems, and such systems are always open systems. Instead of constructing a sandbox in which the AI can evolve by itself, there are communication layers between a robot and the environment which are described by symbols in a mini language.
Computer systems can be categorized into algorithm driven closed system, so called Turing machines, and communication driven open systems which are Choice Machines or interactive machines. The internet is a typical example for an open system based on the TCP/IP layered protocol. The same principle allows to create intelligent robots.
With this longer introduction its possible to explain why AI has failed in the past. The assumption was that intelligence is an algorithm which is running in a closed sytem. The improved understanding formulated by Harnad et. al. is that intelligence is communication needed for human to machine interaction.
Let us go back to cellular automaton and closed system because it allows to recognize a dead end in academic research. Cellular automaton were introduced by John von Neumann as demonstration for a self replicating system. A cellular automaton is a computer algorithm which is running on a 2d grid. The algorithm never communicates with the environment, its not a "Karel the robot" playground but a cellular automaton follows its own rule. The hope was that with the correct starting condition plus an evolutionary algorithm it would be possible to generate life within a computer, similar how biological life has evolved.
Stephen Wolfram has improved the idea into 1d cellular automaton which are working the same way like a Turing machine. His contribution was that such 1d automaton are described from a strict mathematical perspective. Such a rigid mathematical closed system is unable to communicate with the environment, therefor its the opposite of artificial intelligence in a modern understanding.
The good news is, that the Artificial life community has shown that their approach is a dead end. There is no need to explore the approach with more effort but the assumption itself of algorithms running inside a closed system can't generate intelligence.
April 12, 2026
From turing machines to artificial intelligence
A turing machine is a closed system which executes an internal algorithm but doesn't receives sensory data. This restriction allows to describe turing machines in an elegant mathematical fashion and makes it easy to implement turing machines in hardware. Unfurtunately, the inability of turing machines to receives external input for example from a human or an oracle, will prevent artificial intelligence because closed systems can only solve well definied routine problems but fail in advanced creative subjects.
Oracle turing machines or choice machines have the ability to process external information. Realizing such an advanced turing machine in software is surprisingly easy. A robot may stop on a junction and ask the human operator with a multiple choice drop down field what the robot should do next. The human operator can select "move left" or "move right". The selection of the human is submitted to the robot as external guidance and the robot can continoue his mission.
Such kind of robots are sometimes called an open system because the robot communicates with the environment. Instead of executing a predefined program the robot interacts with a higher instance. Such kind of interactive computing can't be described in classical algorithm terms anymore but the man to machine communication is at foremost a communication process from a sender to a receiver.
Modern artificial intelligence is dealing exclusively with open system which are able to communiate but not with closed system which can execute only a predefined algorithm. Open systems are more powerful but also harder to describe because of the mentioned communication language with the external world.
April 10, 2026
AI powered by natural language
An often asked question in the last 70 years of robotics research was: where is the AI located in a robot? It took around the year 2010 until researchers have answered this important question. The AI brain is located in natural language. A state of the art robot converts natural language into servo motor movements and has a access to large database with natural language commands. This allows the machine to think, take decisions and act.
The principle of realizing artificial intelligence with natural language was imagined before the year 2010 in projects like Televox robot (1929), SHRDLU (1968), Maniac Mansion game (1987) and Vitra visual translator (1987). The innovation which takes place after the year 2010 was, that AI was located only in English sentence but not in other potential sources like path planning algorithms, genetic algorithms, neural networks or expert systems.
The claim is that without natural language interface, its impossible to program a robot. Natural language is the only needed and most powerful tool to realize intelligent machines. There is no need to focus only on the English language because other human languages like German or French works also well. The only precondition is, that its a natural language with a large vocabulary to describe the reality in nouns, adjectives and verbs. Its not possible to use a programming language like Java or C++ for this purpose, but only natural language are powerful enough to grasp the environment of a robot.
Modern robotics after the year 2010 can be described as a semiotic interpretation engine which is able to use grounded language to convert high level symbols into low level motor actions. In other words, modern robotics doesn't work with algorithms or computer programs but the AI was realized with an advanced user interface similar to what is known from Maniac Mansion adventure game. The user interface on the bottom of the screen allows a human to machine interaction and this translation process can generate artificial intelligence.
April 09, 2026
Dataset for grounded language
A DIKW pyramid consists of 4 layers for describing multiple abstraction level for a game state. In the context of a warehouse robot the following dataset is available. The task for the neural network is to translate between the layers, this allows a human to machine communication. Human are expressing in full english sentences, while machines are measuring the environment in numerical sensor values.
[
{
"id": 1,
"data": {"pos": [40, 10], "rgb_color": [255, 0, 0], "dist": 2.0, "trajectory": "traj3", "battery": 0.7},
"information": ["box", "red", "kitchen", "entrance"],
"knowledge": "Pick up the red box in kitchen room"
},
{
"id": 2,
"data": {"pos": [15, 5], "rgb_color": [0, 0, 255], "dist": 1.5, "trajectory": "traj1", "battery": 0.65},
"information": ["box", "blue", "corridor", "obstacle"],
"knowledge": "Move the blue box out of the corridor to clear the obstacle"
},
{
"id": 3,
"data": {"pos": [60, 30], "rgb_color": [255, 255, 0], "dist": 5.0, "trajectory": "traj_return", "battery": 0.15},
"information": ["charging_station", "yellow", "dining_room", "low_battery"],
"knowledge": "Aborting task: Return to dining room for immediate charging"
},
{
"id": 4,
"data": {"pos": [45, 12], "rgb_color": [100, 70, 20], "dist": 0.5, "trajectory": "none", "battery": 0.58},
"information": ["obstacle", "brown", "kitchen", "entrance", "blocked"],
"knowledge": "Wait for 10 seconds: Entrance is blocked by a moving obstacle"
},
{
"id": 5,
"data": {"pos": [10, 80], "rgb_color": [200, 200, 200], "dist": 10.0, "trajectory": "traj_search", "battery": 0.9},
"information": ["room", "corridor", "empty", "pickup_zone"],
"knowledge": "Scanning corridor: No items found in designated pickup zone"
},
{
"id": 6,
"data": {"pos": [33, 44], "rgb_color": [0, 255, 0], "dist": 0.1, "trajectory": "traj_dock", "battery": 0.5},
"information": ["box", "green", "dining_room", "drop"],
"knowledge": "Drop the green box at the delivery point in the dining room"
},
{
"id": 7,
"data": {"pos": [5, 5], "rgb_color": [255, 0, 0], "dist": 2.2, "trajectory": "traj_safety", "battery": 0.45},
"information": ["hazard", "red", "corridor", "liquid_spill"],
"knowledge": "External command: Avoid red marked area due to a spill in the corridor"
},
{
"id": 8,
"data": {"pos": [50, 50], "rgb_color": [255, 255, 255], "dist": 0.0, "trajectory": "none", "battery": 0.4},
"information": ["inventory_list", "mismatch", "kitchen", "room"],
"knowledge": "Import external data: Re-scan kitchen room to update missing inventory"
}
]
Warum Python in der Spieleentwicklung Rust überlegen ist
Die Rust Community behauptet eine Allzweck programmiersprache geschaffen zu haben die für alle Aufgaben von low level bis high level empfohlen wird. Und folglich ist es nur eine Frage der Zeit bis veraltete Programmiersprachen wie C++, Java oder Javascript durch Rust ersetzt werden.
Es gibt jedoch berechtigte Kritik an der Rust Sprache die kurz erläutert werden soll. Moderne Softwareentwicklung basiert zwingend auf der zuhilfenahme eines Large language models, und sei es nur um Fehler im Code zu finden. Der Nutzer postet ein Codesnippet in das LLM seiner Wahl und erhält anders als bei Stackoverflow unmittelbar die korrekte Antwort und muss nicht erst 2 Tage warten.
Large Language modelle sind zwar technisch in der Lage in jeder Programmiersprache den Code zu erstellen, aber ihre Datenbasis wurde mit einer unterschiedlichen Menge an Beispielcode gefüttert. Mainstreamsprache wie Python oder C# werden von LLMs am besten verstanden weil die Menge an Beispielcode von github und die Menge an Tutorials am größten ist. Die These lautet dass jene Programmiersprache die beste ist, die die größte Verbreitung hat, so ähnlich wie English die beste Weltsprache ist, weil es von den meisten Sprechern verwendet wird.
Rust fristet zahlenmäßig ein Nischendasein, es gibt zwar durchaus beispielcode bei github worin gezeigt wird, wie man ein Tetris spiel inkl. grafischer Oberfläche programmiert, für das selbe Problem gibt es in der Sprache jedoch hunderte oder sogar noch mehr Respositorien. Ein weiteres Problem bei Rust ist dass wegen der Neuheit sich die Syntax laufend ändert und die Sprache selber Gefahr läuft durch modernene Forks wie Rue ersetzt zu werden. Das mag hilfreich sein bei der Weiterentwicklung einer modernen Allzwecksprache die über einen eingebauten Memory checker verfügt, macht aber über Nacht den vorhandenen Sourcecode bedeutungslos und fragmentiert das Ökosystem weiter. Das kann bei Python und C# nicht passieren. Die Menge an Beispielcode ist riesig und wächst konstant.
Hier mal einige Zahlen.
- Anzahl Stackoverflow Fragen für Rust: 45k
- Anzahl Stackoverflow Fragen für Python: 2.2 Million
Automatisierung von Teleoperation in der Robotik
Es gibt einen rationalen Grund warum ferngesteuerte Robotik über Jahrzehnte ein Schattendasein führte. Und zwar benötigt teleoperation einen menschlichen Bediener und lässt sich nicht automatisieren. Robotik versucht jedoch explizit Prozesse zu automatisieren ohne dass dafür menschliche Bediener nötig sind. Ergo wurde Teleoperation als Sackgasse definiert.
Seit ca. 2010 erlebten Ferngesteuerte Roboter ein Revival was auf ein besseres Verständnis für teilautonome Systeme zurückzuführen sind. Frühere Bedenken gegenüber ferngesteuerten Systemen konnten entkräftet werden. Teleoperation kann sehr wohl automatisiert werden und das soll kurz erläutert werden.
Angenommen ein ferngesteuerte Lagerroboter versteht einen Befehl wie "fahre in Raum B und bring mir die Box #4". Streng genommen handelt es sich nicht um einen autonomen roboter sondern wegen des Befehls ist es nur ein ferngesteuerter Roboter. Die Interaktion lässt sich aber mittels Script leit automatisieren. Im SCript steht folgende Sequenz:
1. "fahre in Raum B und bring mir die Box #4"
2. "fahre in Raum A und bring mir die Box #2"
3. "fahre in Raum B und bring mir die Box #8"
4. "fahre in Raum D und bring mir die Box #12"
5. "fahre in Raum C und bring mir die Box #1"
Nach Ausführung dieser Sequenz hat der Roboter ohne weitere Interaktion immerhin 5 unterschiedliche Boxen von verschiedenen Standorten geholt. Er war dazu mehrere Minuten im Einsatz und verhielt sich fast wie ein autonomes System. Wenn die Kopmmandos auf einer hohen Abstraktionsebene formuliert werden, wie im obigen Beispiel zu sehen, ist es keine klassische Joystick Teleoperation mehr sondern solche Systeme haben starke Ähnlichkeit mit autonomer Roboter.
Zwar erhält der Roboter technisch gesehen Befehle von einem menschlichen Bediener, denkt also nicht selber, nur kann die o.g. Befehlssystsem auch in einem SCript oder Makro gespeichert sein, es wird also gar kein menschlicher Bediener benötigt sondern der mensch erstellt einmalig ein Script und damit wird der Roboter autonom.
Die Frage ist weniger ob ein System autonom, teilautonom oder ferngesteuert funktioniort sondern die eigentliche Frage ist auf welchem Abstraktionslevel die Fernsteuerung erfolgt. Wenn über einen joystick lowlevel steuersignale gesendet werden sind diese tatsächlich nur schwer zu scripten. Man kann die Joystick kommandos nicht aufzeichnen und erneut abspielen weil der Roboter in einer anderen Ausgangsposition startet. Wenn jedoch die fernsteuerung mittels text interface erfolgt lassen sich die kommandos leicht aufnehmen und erneut einsetzen. Es lassen sich sogar Programme schreiben, um die Scripte automatisiert zu erzeugen.
Moderne Ferngesteuerte Robotik ab ca. 2010 versucht primär über Text interfaces ein hohes Abstraktionsniveau zu erreichen bei der Mensch maschine Kommunikation. Damit kommt man dem Ziel einer künstlichen Intelligenz sehr nahe.
April 08, 2026
The need for human to robot communication
Layered communication with a DIKW pyramid solves a simple problem: how human can submit commands to a robot. For example the human operator submits "bring me the red box" to the robot and the robot will fetch the box.
The unsolved question is why such a human to robot interaction is needed? In the classical understanding of AI until the 2000s, such kind of pattern was interpreted as a dead end. Artificial intelligence was described as autonomous system which doesn't need to communicate with humans. If a robot doesn't communicates with humans the robot is described as a closed system which is able to run a computer program written in C or runs a neural network algorithm but the robot isn't using human language because there is no need for doing so.
Grounded language realized in AI systems like SHRDLU (1968), Vitra (1987) and M.I.T. Ripley robot (2003) is only needed if human to machine interaction is intended. A possible explanation for this paradigm shift has to do with the weakness of closed AI systems. Existing attempts to build autonomous robots have failed because closed systems are overwhelmed by a complex environment. Even if the robot's software consists of 100k lines of code in the C/C++ language this code won't match to a warehouse robot task because ambiguity and vague goals. Classical computer programming language are working only in a predicted environment like sorting an array or showing pixels on a monitor. Computer programs are the internal language of machines but the code can't store the knowledge for robots task.
Before the advent of human to machine interaction there was another available to build more powerful software for robots based on ontologies. Instead of storing the world knowledge in computer code the goal was to capture knowledge in a Cyc like mental map. Unfortunately, this concept has failed too. Even OWL ontologies are not powerful enough to store domain knowledge. Only teleoperation matches to high complexity. A teleoperated robot arm can do any demanding task including dexterous grasping and novel trajectories never seen before.
During teleoperation the AI problem gets outsourced from the robot itself towards an external source which is the human operator. The teleoperation interface allows a man to machine interaction which translates the external knowledge into robot movements.
April 07, 2026
Introduction to the Rust Programming Language: Safety, Speed, and Sovereignty
The landscape of systems programming is undergoing a generational shift. For decades, C and C++ were the undisputed kings of performance, but they carried a heavy burden: memory unsafety. Most Common Vulnerabilities and Exposures (CVEs) in modern software are caused by memory leaks and "use-after-free" errors in legacy C/C++ code. Enter Rust, a language designed to provide the performance of C with the safety guarantees of a managed language.
Origins and Philosophy
Rust was created by Graydon Hoare (who also contributed significantly to the development of Apple’s Swift). Because of this shared lineage, developers often notice a familiar, modern syntax between the two languages. Unlike languages that rely on a Garbage Collector (GC)—a process that periodically scans and removes unused memory—Rust introduces a revolutionary Ownership Model.
In C, developers must manually manage memory using malloc and free, often relying on external tools like Valgrind to hunt down leaks. C++ improved this with smart pointers, but Rust takes it a step further at the compiler level.
The Power of Ownership
The heart of Rust is its ownership system, governed by three strict rules:
Each value in memory has a variable that’s called its owner.
There can only be one owner at a time.
When the owner goes out of scope, the value is automatically dropped (cleared from memory).
This prevents memory leaks and ensures that a "use-after-free" error is physically impossible to compile. This level of safety is why giants like Microsoft are planning to transition significantly to Rust by 2030, and why even the Linux Kernel has begun integrating Rust code (currently sitting at roughly 0.3%).
Ecosystem and Tooling
The developer experience in Rust is centered around Cargo, its highly praised build system and package manager.
Project Initialization: Use cargo init --bin to start a new project.
Dependency Management: Simply edit the Cargo.toml file to add a "crate" (Rust's term for a library).
Execution: Run cargo run to compile and launch your application.
Rust is also being used to build entire operating systems, such as Redox OS. Redox is a Unix-like OS written entirely in Rust, featuring its own display server called Orbital and supporting the NetSurf browser.
Learning Through Graphics and Games
Many developers find that the best way to master Rust's strict compiler is through visual projects. The Piston engine is a long-standing choice for game development, but for those seeking simplicity, Macroquad is an excellent library for 2D/3D graphics.
Developer Note: If you encounter errors like "floating point arithmetic is not allowed in constant functions" while using Macroquad on Linux Mint, ensure your compiler is up to date by running rustup update stable.
References and Further Reading
- From C# to Rust: A 42-Day Challenge https://woodruff.dev/from-c-to-rust-a-42-day-developer-challenge/
- Microsoft: Rust to Replace C/C++ by 2030 https://www.martinsfeld.de/blog/microsoft-rust-ersetzt-c-cpp-2030/
- Game Development in Rust with Macroquad https://mq.agical.se/
- The Rust Programming Language (Official Book) https://doc.rust-lang.org/book/
Grounded language in robotics
The symbol grounding problem and especially the detail of grounded language is a very new subject in computer science. It needs to be explained because its the key element of artificial intelligence. As an introductory example a warehouse robot has stored a json file:
{
"knowledge": "pick up the red box in kitchen room",
"information": [box, obstacle, entrance, room, pickup, drop, red, blue, yellow, kitchen, corridor, dining room],
"data": [pos=(40,10), rgb_color=(100,70,20), dist=20, trajectory=traj3, direction=(40,10), battery=0.7],
}
This json file shows 3 of 4 layers from a DIKW pyramid. It is the current situation of the robot also known as the game state. According to the DIKW pyramid, this current situation is stored in different layers which have a different abstraction. The lowest data layer stores numerical information gathered from hardware sensors. While the information layer stores the vocabulary and the knowledge layer stores a concrete instruction.
The main task of the robots artificial intelligence is to translate between these layers. The human enters a command and the robot understands the command because its translated into the low level data layer. This translation process is called grounded language.
In contrast to former natural language processing (NLP) the goal is not to check the grammar of the input instruction e.g. to verify that the word "room" is a noun or that "red" is an adjective. So the question is not what language is by itself, but the problem has to do with converting from high level abstraction towards low level abstraction in the DIKW layers.
April 05, 2026
Annotating a warehouse robot
The table shows a simple warehouse game played in a 1d corridor. The robot R has to reach the target T and charge its battery at the Start S. Implementing such a mini game is usually realized with an array for storing the position of the objects.
What makes the simulation more demanding is the introduction of grounded language in the form of [tags]. These tags are used to describe the situation on a semantic level. In a DIKW pyramid, the 1d ascii corridor might be the data level, while the tags are the information level.
| 1D ASCII Corridor | Annotation with [Tags] |
[S R . . . . . T] | [at_start] [near_station] [status_idle] [path_clear] |
[. S . R . . . T] | [moving_east] [leaving_station] [battery_optimal] |
[. S . . R . . T] | [moving_east] [mid_corridor] [calculating_distance] |
[. S . . . R . T] | [near_target] [decelerating] [scanning_area] |
[. S . . . . R T] | [at_target] [loading_process] [task_active] |
[. S . . . . T R] | [target_passed] [reversing] [adjusting_position] |
[. S . . . R . T] | [moving_west] [returning_to_base] [low_battery_warning] |
[R S . . . . . T] | [docking] [at_station] [recharging] [task_complete] |
April 04, 2026
A closer look into the Rust programming language
Rust is a very new programming language available since 2015. The main problem with Rust is, that its harder to learn than C/C++. Let us describe the situation in detail.
Before the invention of the Rust language, the programming world was divided into beginners languages like Python and Java on the one hand and expert languages like C++, Haskel and Assembly.
A programming language like Python is called a beginner language because its interpreted but not compiled, because there are no datatypes and because the code is easy to read. The disadvantege of Python is well known but for creating prototypes Python is perhaps the best programming language ever invented.
Creating production ready code was mostly done in C++ which is a very efficient language but is hard to write. Rust can be seen as twice as complicated as C++ because it introduces many new concepts and is very different from existing languages like go, java or C#.
The main reason why Rust has become popular is because its newer than the C++ standard. It doesn't provide endless amount of outdated principles but was designed from scratch for productive tasks. So its soem sort of rewrite of the D Language which was also started as a C++ replacement.
In contrast to former C++ replacements like nim, golang and objective c, the Rust language has become more popular. It seems that the demanding learning curve results into efficient software projects which can compete and outperform C++.
The main reason why Rust hasn't replaced C++ yet is because its very new and different, Programmers have to unlearn former knowledge and start from scratch which is a huge obstacle.
April 03, 2026
The long history of artificial intelligence
Historians are introducing Artificial intelligence with the fact that the subject was researched for over 50 years without much effort. This makes AI research to the most unsuccesful sciences. In contrast to other disciplines like mathematics, physics or psychology its completely unclear what AI is about and how to make computer smart. A closer look into the facts will show that the situation is more dramatic, because AI was researched since 70 years because the Dartmouth conference on AI was held in 1956.
Despite lots of robotics project and a huge amount of published papers there is little or no progress available. Before the advent of chatgpt in Nov 2022, the subject was nearly unknown in public awareness. What was available instead was classical computer science in the form of PCs, the internet and modern gadgets like the iphone. In contrast, the goal of building intelligent machinery was perceived as impossible to realize.
One possible explanation why AI research from the last 70 years is perceived as a dead end is because there are no logic bricks available which are building on each other. Of course many dedicated robotics software frameworks and AI programming languages were created but none of them are perceived as important. There is no such thing available like the x86 hardware standard for AI or the Unix specification which allows other programmers to build on top of the standard new application. Instead the common AI project in the past was started by a few researchers who have written some code and discussed the results in a conference paper and other researchers have read the paper and decided that the outcome makes no sense so they started their own project from scratch.
There is one exception from this rule available which is responsible to the emergence of Artificial intelligence since the year 2010. So called deep learning datasets have become the standard in AI research. A dataset is a table with annotated information, like motion capture data, picture database and more recently multimodal dataset with question answer pairs. These datasets have evolved from simple table with 2000 entries up to larger table created by different researchers in a multi year effort. A certain dataset formulates a puzzle which has to be solved by a neural network. The network has the obligation to interpolate missing data and reproduce existing question answer pairs. For example the neural network is feed with a walking sequence of a human and the neural network recognizes that the left foot is in front of the right foot.
In contrast to the mentioned endless amount of AI libraries and AI algorithm, the dataset principle is surprisingly stable. Dataset were used in the year 2000, in 2010, in 2020 and are also relevant for the future. The assumption is, that datasets are a fundamental building blocks in creating intelligent machines.
In modern understanding an AI dataset acts as a benchmark to score a machine learning algorithm. The ability to score an algorithm transforms AI research from alchemy into a scientific disciplines. Instead of arguing from a philosophical standpoint if machines can think, the question is what the numerical score in a benchmark is. Such a fact can be compared against each other and allows to determine a direction for future research.
April 02, 2026
Rückblick auf das Vitra Projekt SFB 314
Deutschland
gilt in der KI Szene als rückständig, innovationsfeindlich und
dominiert von philosophischen Debatten anstatt technischer Projekte.
Es gibt jedoch davon durchaus Ausnahmen wie das Vitra Projekt was im
Jahr 1987 von Wolfgang Wahlster durchgeführt wurde. Vitra steht für
"visual translator" und war ein Großforschungsprojekt im
Umfang von 50 Mio DM was erstmalig Bilderkennung und Sprache
kombinierte. Technisch wurde es auf VAX Minicomputern und Symbolics
Workstations realisiert.
Aus heutiger Sicht würde man
Vitra als "Vision language model (VLM)" definieren, nur das
es damals nicht mit neuronalen Netzen arbeitete, sondern mit händisch
erstelltem Lisp Sourcecode. Ähnlich wie die Zuse Z3 aus dem Jahr
1941 war das Vitra Projekt konkurrenzfähig oder sogar leicht
überlegen der US amerikanischen Spitzenforschung.
Die
Hauptkritikpunkt an Vitra war, dass es zu teuer war. Man verwendete
Großrechner um in Echtzeit Videobilder zu analysieren. Auch die Lisp
Programmiersprache war ein Kostenfaktor, weil man Spezialisten
benötigte, die Lisp programmieren können. Dieses Konzept, bestehend
aus VAX Rechnern, Lisp und Livekameras, kann man nicht hochskalieren
zu noch mehr Komplexität, sondern Vitra war eine Art von
Dinosaurier, der eine Sackgasse darstellte.
Aus heutiger
Sicht würde man viel kleinere Forschungsprojekte durchführen. Man
würde nicht Lisp sondern Python wählen und man würde keine
Videobilder von Kameras parsen sondern lediglich Screenshots von
Videospielen analysieren. Damit könnte der Aufwand zur Realisierung
auf ein Bruchteil gesenkt werden.
April 01, 2026
Mülltrennung als Computerspiel
import pygame
import random
# Initialisierung
pygame.init()
# Fenster-Einstellungen
WIDTH, HEIGHT = 900, 650 # Etwas breiter für die 5. Tonne
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Müll-Profi: Jetzt auch mit Glas!")
# Farben
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
BLUE = (0, 102, 204) # Papier
YELLOW = (255, 204, 0) # Verpackung
BROWN = (102, 51, 0) # Bio
GRAY = (50, 50, 50) # Restmüll
DARK_GREEN = (0, 100, 0) # Glas
LIGHT_GREEN = (0, 255, 0) # Feedback Richtig
RED = (255, 0, 0) # Feedback Falsch
# Schriftarten
font = pygame.font.SysFont("Arial", 22, bold=True)
title_font = pygame.font.SysFont("Arial", 36, bold=True)
# Erweiterte Müll-Daten (Insgesamt 22 Items)
# Erweiterte Müll-Daten (Jetzt insgesamt 42 Items!)
WASTE_ITEMS = {
# PAPIER (Blau) - Nur sauberes Papier!
"Zeitungen": BLUE, "Karton": BLUE, "Schulheft": BLUE, "Prospekte": BLUE,
"Briefumschlag": BLUE, "Eierkarton": BLUE, "Mehltüte (leer)": BLUE, "Geschenkpapier": BLUE,
# GELBER SACK / TONNE (Gelb) - Verpackungen aus Plastik, Metall, Verbundstoff
"Getränkedose": YELLOW, "Plastetüte": YELLOW, "Joghurtbecher": YELLOW,
"Milchtüte": YELLOW, "Alufolie": YELLOW, "Shampooflasche": YELLOW,
"Konservendose": YELLOW, "Butterfolie": YELLOW, "Kronkorken": YELLOW,
"Styropor": YELLOW, "Chipsdose": YELLOW,
# BIO (Braun) - Organisches
"Apfelrest": BROWN, "Bananenschale": BROWN, "Kaffeesatz": BROWN,
"Eierschalen": BROWN, "Rasenschnitt": BROWN, "Teebeutel": BROWN,
"Orangenschale": BROWN, "Kartoffelschalen": BROWN, "Welke Blumen": BROWN,
# RESTMÜLL (Grau) - Alles Verschmutzte oder Nicht-Verwertbare
"Zahnbürste": GRAY, "Windel": GRAY, "Staubsaugerbeutel": GRAY,
"Asche": GRAY, "Zigarette": GRAY, "Pizzakarton (fettig)": GRAY,
"Backpapier": GRAY, "Kaugummi": GRAY, "Putzlappen": GRAY,
"Katzenstreu": GRAY, "Alte Fotos": GRAY,
# GLAS (Grün) - Behälterglas (kein Trinkglas/Fensterglas!)
"Weinflasche": DARK_GREEN, "Marmeladenglas": DARK_GREEN, "Senfglas": DARK_GREEN,
"Ölflasche (Glas)": DARK_GREEN, "Parfümflakon": DARK_GREEN
}
class Bin:
def __init__(self, color, x, label):
self.rect = pygame.Rect(x, HEIGHT - 160, 140, 140)
self.color = color
self.label = label
class DraggableItem:
def __init__(self, text, target_color):
self.text = text
self.target_color = target_color
self.reset_position()
self.dragging = False
def reset_position(self):
self.rect = pygame.Rect(WIDTH // 2 - 75, 180, 150, 45)
# 5 Tonnen erstellen
bins = [
Bin(BLUE, 30, "Papier"),
Bin(YELLOW, 200, "Gelber Sack"),
Bin(BROWN, 375, "Bio"),
Bin(DARK_GREEN, 550, "Glas"),
Bin(GRAY, 725, "Restmüll")
]
# Spiel-Variablen
score = 0
feedback_text = "Zieh das Wort in die richtige Tonne!"
feedback_color = BLACK
def get_new_item():
name = random.choice(list(WASTE_ITEMS.keys()))
return DraggableItem(name, WASTE_ITEMS[name])
current_item = get_new_item()
running = True
while running:
screen.fill((240, 240, 240)) # Hellgrauer Hintergrund
# UI Zeichnen
title = title_font.render("Müll-Sortier-Station", True, BLACK)
screen.blit(title, (WIDTH//2 - title.get_width()//2, 30))
score_display = font.render(f"Punkte: {score}", True, BLACK)
screen.blit(score_display, (30, 30))
# Tonnen zeichnen
for b in bins:
pygame.draw.rect(screen, b.color, b.rect, border_radius=8)
# Beschriftung der Tonne
txt_color = WHITE if b.color != YELLOW else BLACK
txt = font.render(b.label, True, txt_color)
screen.blit(txt, (b.rect.centerx - txt.get_width()//2, b.rect.y + 55))
# Aktuelles Item zeichnen
if not current_item.dragging: # Schatten-Effekt wenn nicht gezogen
pygame.draw.rect(screen, (200, 200, 200), current_item.rect.move(3, 3), border_radius=10)
pygame.draw.rect(screen, WHITE, current_item.rect, border_radius=10)
pygame.draw.rect(screen, BLACK, current_item.rect, 3, border_radius=10)
item_txt = font.render(current_item.text, True, BLACK)
screen.blit(item_txt, (current_item.rect.centerx - item_txt.get_width()//2, current_item.rect.y + 10))
# Feedback
f_txt = font.render(feedback_text, True, feedback_color)
screen.blit(f_txt, (WIDTH//2 - f_txt.get_width()//2, 120))
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
elif event.type == pygame.MOUSEBUTTONDOWN:
if current_item.rect.collidepoint(event.pos):
current_item.dragging = True
mouse_x, mouse_y = event.pos
offset_x = current_item.rect.x - mouse_x
offset_y = current_item.rect.y - mouse_y
elif event.type == pygame.MOUSEBUTTONUP:
if current_item.dragging:
current_item.dragging = False
hit_bin = False
for b in bins:
if current_item.rect.colliderect(b.rect):
if b.color == current_item.target_color:
score += 10
feedback_text = f"Richtig! {current_item.text} gehört in {b.label}."
feedback_color = LIGHT_GREEN
else:
score -= 5
feedback_text = f"Falsch! {current_item.text} ist kein {b.label}!"
feedback_color = RED
current_item = get_new_item()
hit_bin = True
break
if not hit_bin:
current_item.reset_position()
elif event.type == pygame.MOUSEMOTION:
if current_item.dragging:
mouse_x, mouse_y = event.pos
current_item.rect.x = mouse_x + offset_x
current_item.rect.y = mouse_y + offset_y
pygame.display.flip()
pygame.quit()
AI without programming
Computer science is mostly organized around programming languages. There are imperative languages like C, there are object oriented language like Java and there are modern languages like Python. A common strategy was to implement artificial intelligence in a programming language. The reason is, that a computer which is running a program is the most powerful and often the only tool available in computer science. So the assumption was, that this workflow can be adapted towards artificial intelligence.
Unfortunately, this concept doesn't work in reality. Even many AI related projects were implemented in C++ and lots of industrial robots were programmed in a robot programming language the concept of implementing AI in a programming language is a dead end. Even high level languages like Python doesn't provide the needed elements or libraries needed for making a computer smart. A computer program will run only in a predefined fashion which is the opposite of adaptive systems which are able to solve complex tasks.
The answer to the challenge is to avoid programming languages at all and imagine Artificial intelligence in a non computer science perspective. Instead of asking how to implement AI on a computer the new question is who can humans communicate with robots. This question goes beyond software engineering but it asks for protocols similar to TCP/IP. Implementing a communication protocol in C or in Python is only a detail problem and can be ignored in most AI related projects.
The computer shouldn't be described as a computational machine but as a message transceiver. There are incoming messages from a human and there are outgoing messages back to the human. Artificial intelligence means to formalize this process with a protocol, with a vocabulary and with a grammar. This task can't be described in classical software paradigm but it has to do with protocol design and inventing a domain specific language.
Let me give an example. Suppose the goal is to create a warehouse robot. Such a robot will needed a list of nouns like "obstacle, path, battery, box, barcode" and the robot will need a list of verbs like "stop, forward, rotate, scan, grasp". These nouns and verbs can be combined into sentences and some adjectives may help to communicate in difficult situations. Computer science and especially software engineering is the wrong discipline to describe the robot's vocabulary but it has more in common with linguistics not related to computing anymore.
March 30, 2026
Grounded text to action for playing Maniac Mansion
In addition to the previous attemps to play the point&click adventure Maniac mansion with a large language model here is a more compressed repreentation. Its a 3 column table with a timecode, a textual desription, and low level mouse actions.
The textual description is located on the information layer of the DIWK pyramid, while the mouse movements are on the bottom data layer.
Timecode Textual Description ScummVM Mouse Movements / Interaction
00:05 Select Character: Bernard Move cursor to Bernard's portrait (bottom right); Left-Click.
00:08 Move to Front Gate Move cursor to far right of driveway; Left-Click.
00:15 Walk to Front Door Move cursor to porch steps; Left-Click.
00:20 Action: "Pull" Door Mat Click "Pull" (verb pane); Click "Door Mat" (on porch floor).
00:24 Action: "Get" House Key Click "Get" (verb pane); Click "Entrance Key" (revealed on floor).
00:28 Action: "Use" Key on Door Click "Use"; Click Key (inventory); Click "Front Door".
00:32 Enter Mansion (Main Hall) Move cursor to open doorway; Left-Click.
00:40 Action: "Get" Flashlight Walk to the small table near the stairs; Click "Get"; Click "Flashlight".
The main task for the sofrware is translation. A high level textual description gets converted into low level action. E.g.:
textual description= Action: Use Key on Door
mouse movement=Click "Use"; Click Key (inventory); Click "Front Door".
In other words the DIKW pyramid is mostly an abstraction mechanism which consists of different details for the same task. The AI for playing Maniac Mansion hasn't decide anything, but the AI takes a textual description as input and generates low level mouse movements as output.
Here is the workflow how to play the game with an AI. The human user has to provide the textual description what to do in each scene. For example the human enters "walk to front door". This input command is converted by the computer into mouse actions on the screen and executed by the computer. So the Maniac Mansion game gets teleoperated with an advanced textual interface. This interface reduces the workload for the human operator. He is no longer forced to move the mouse directly on the verbs and the objects, but the human enters text into the command line.
Its a bit complicated to explain why such a DIWK workflow works in reality. From a technical perspective, natural language was utilized as an abstraction mechanis to reduce complexity. Instead of solving the original task of moving the mouse on the screen and click on items, the new task to provide a textual walk through which gets converted automatically into mouse movemens.
This abstraction mechanism works only because natural language, here English, is a powerful tool. It provides all the needed vocabulary including grammar to formulate complex tasks. There is no need to develop computer algorithm, neural networks or cognitive architectures, but natural language itself is the asset for enabling artificial intelligence.
March 28, 2026
Human to robot interaction with a dikw pyramid
Maniac Mansion is a well known point&click adventure. With the help of a walk through tutorial its possible to win the game. The standard tutorial consists of keypoints and full sentences written in English which can be read by humans but can't be executed by a computer. With a converter from high level to a low level layer its possible to transform the walk through tutorial into machine readable commands. The process is demonstrated with the following json code adressing the kitchen scene:
{
"card_id": "MM_KITCHEN_01",
"scene_title": "The Mansion Kitchen - ScummVM Navigation",
"content": {
"textual_description": {
"objective": "Enter the kitchen to retrieve the Small Key from the counter while staying alert for Nurse Edna.",
"key_points": [
"The kitchen is located through the first door on the right in the main hallway.",
"Crucial Item: The Small Key is sitting on the counter near the sink.",
"Hazard: Opening the refrigerator triggers a cutscene/event that can lead to capture.",
"Exit Strategy: Use the door to the far right to enter the Dining Room if the hallway is blocked."
]
},
"low_level_representation": {
"engine_context": "ScummVM - 320x200 Resolution (Original Scale)",
"mouse_interactions": [
{
"step": 1,
"verb_action": "PICK UP",
"verb_coordinates": { "x": 40, "y": 175 },
"target_object": "Small Key",
"target_coordinates": { "x": 165, "y": 115 },
"result": "Key added to character inventory."
},
{
"step": 2,
"verb_action": "WALK TO",
"verb_coordinates": { "x": 10, "y": 165 },
"target_location": "Dining Room Door",
"target_coordinates": { "x": 305, "y": 110 },
"result": "Character transitions to the next room."
}
],
"safety_note": "Avoid clicking 'OPEN' (x: 10, y: 175) on the Refrigerator (x: 240, y: 90) unless you have a specific distraction planned."
}
}
}
Both layers (low level and high level) are describing the same scene which is to enter the kitchen and fetch the key. The difference is, that that the layers have a different abstraction level. The high level layer is prefered by humans and mirrors how humans are thinking and how they are using language. In contrast, the low level layer is prefered by machines who are programmed with a logic oriented mathematical notation.
The converter has the task to translate between these layer which is known as the symbol grounding problem. Solving the grounding problem means to improve human to machine interaction.
Solving the first scene in Maniac Mansion with a DIKW pyramid
Symbol grounding means basically to convert abstract description into detailed description. A concrete example with 3 layers for the first scene of the point&click adventure Maniac Mansion is shown next. The textual description can be understood by a human easily but can't be submitted directly to a computer. In contrast, the low level "pyautogui_commands" are hard to read for a human but can be processed by a computer program with ease.
Symbol grounding means basically that an algorithm converts high level descripiton into low level commands. With such a grounding algorithm its possible to script the game by providing textual description and the Artificial intelligence converts these description into mouse movements which are submitted to the SCUMMVM engine.
{
"notecard_id": 1,
"scene_title": "The Front Yard",
"content": {
"textual_description": {
"objective": "Gain entry to the Edison Mansion.",
"key_points": [
"Start with Dave outside the main gate.",
"Walk toward the front door of the mansion.",
"The door is locked; the key is hidden nearby.",
"Look under the doormat to find the silver key.",
"Use the key to unlock the door and enter."
]
},
"low_level_representation": {
"resolution_reference": "800x600",
"actions": [
{
"step": 1,
"action": "Select Verb: WALK TO",
"pixel_coords": [120, 480],
"note": "Clicking the 'Walk to' verb in the UI tray."
},
{
"step": 2,
"action": "Target: Front Door",
"pixel_coords": [400, 300],
"note": "Moving the character to the mansion entrance."
},
{
"step": 3,
"action": "Select Verb: PULL",
"pixel_coords": [250, 480],
"note": "Preparing to move the mat."
},
{
"step": 4,
"action": "Target: Doormat",
"pixel_coords": [400, 420],
"note": "Revealing the hidden key."
},
{
"step": 5,
"action": "Select Verb: PICK UP",
"pixel_coords": [50, 520],
"note": "Collecting the key."
}
]
},
"pyautogui_commands": [
"import pyautogui",
"pyautogui.PAUSE = 0.5",
"# Walk to door",
"pyautogui.click(120, 480)",
"pyautogui.click(400, 300)",
"# Pull mat",
"pyautogui.click(250, 480)",
"pyautogui.click(400, 420)",
"# Pick up key",
"pyautogui.click(50, 520)",
"pyautogui.click(405, 425)"
]
}
}
March 27, 2026
Abstieg in der DIKW Pyramide am Beispiel Zak mckracken
Damit ein Large language model ein Videospiel automatisiert durchspielt braucht es mehrere Ebenen aus der DIKW Pyramide. Auf layer 3 (knowledge) wird eine Spielszene in Stichpunkten beschrieben auf einer sehr hohen Abstraktionsschicht. Dies wird dann in den layer2 übersetzt, der viel präziser ist aber weniger leicht zu lesen für einen Menschen und schlußendlich auf den Layer1 transformiert der die low level Daten Ebene darstellt. Der Layer1 kann dann an die Game engine gesendet werden, also an die ScummVM welche das point&click adventure ausführt.
Hier alle 3 layer der DIKW pyramide in einer übersichtlichen json notation.
{
"game": "Zak McKracken and the Alien Mindbenders",
"card_id": 1,
"title": "Morgenroutine in San Francisco",
"representation_1_natural_language": {
"format": "Karteikarte (Menschlich)",
"content": [
"Wache in Zaks Schlafzimmer auf.",
"Nimm das Aquarium-Netz unter dem Bett.",
"Gehe ins Wohnzimmer und nimm die Fernbedienung vom Fernseher.",
"Gehe in die Küche.",
"Nimm das stumpfe Brotmesser aus der Spüle.",
"Öffne den Kühlschrank und nimm das Ei."
]
},
"representation_2_intermediate_logic": {
"format": "Text-to-Action Reasoning (Zwischenschritt)",
"note": "Hier werden implizite Aktionen und Raumwechsel für die KI logisch explizit gemacht.",
"logic_chain": [
{"state": "Room: Bedroom", "goal": "Inventory: Fishnet", "sub_action": "PickUp(Fishnet, under_bed)"},
{"state": "Room: Bedroom", "goal": "Change Room", "sub_action": "WalkTo(Door_West)"},
{"state": "Room: Living Room", "goal": "Inventory: Remote", "sub_action": "PickUp(Remote_Control, on_TV)"},
{"state": "Room: Living Room", "goal": "Change Room", "sub_action": "WalkTo(Door_North)"},
{"state": "Room: Kitchen", "goal": "Inventory: Knife", "sub_action": "PickUp(Bread_Knife, in_Sink)"},
{"state": "Room: Kitchen", "goal": "Access Fridge", "sub_action": "Open(Refrigerator)"},
{"state": "Room: Kitchen", "goal": "Inventory: Egg", "sub_action": "PickUp(Egg, inside_Fridge)"}
]
},
"representation_3_low_level_scumm": {
"format": "SCUMM Engine Executable (Low Level)",
"note": "Direkte Opcode-artige Anweisungen, die Objekten IDs und Verben zuordnen (fiktive IDs).",
"commands": [
{"op": "CUTSCENE_START"},
{"op": "PICK_UP", "obj_id": 142, "comment": "Fishnet"},
{"op": "WALK_TO_OBJECT", "obj_id": 201, "comment": "Door to Living Room"},
{"op": "PICK_UP", "obj_id": 155, "comment": "Remote Control"},
{"op": "WALK_TO_OBJECT", "obj_id": 202, "comment": "Door to Kitchen"},
{"op": "PICK_UP", "obj_id": 160, "comment": "Bread Knife"},
{"op": "OPEN", "obj_id": 175, "comment": "Refrigerator"},
{"op": "PICK_UP", "obj_id": 176, "comment": "Egg"},
{"op": "CUTSCENE_END"}
]
}
}
Das interessante an dem Ansatz ist die Abwesenheit einer künstlichen Intelligenz im klassischen Sinne. Es gibt also kein neuronales Netz oder einen Reinforcement Learning algorithmus welches das Spiel durchspielt sondern die KI wurde so implementiert, dass sie zwischen den layern der DIWK pyramide eine Übersetzung ausführt. Wenn man möchte dass im Videospiel eine andere Aktion ausgeführt wird, schreibt man in den obersten Layer andere Stichworte hinein, die werden dann in echtzeit in die unteren Layer transformiert und ausgeführt. Das prinzip ist vergleichbar mit Unix pipes, also einer Filterkaskade die input in output übersetzt.
LLMs als ingame AI
Large language modelle genießen eine große Popularität doch bisher wird dessen Potential nur teilweise ausgeschöpft. So finden LLM ihren Einsatz als Suchmaschine, zum Programmieren oder um Fragen zu beantworten. Hingegen werden sie kaum bis gar nicht eingesetzt um Computerspiele automatisiert durchzuspielen. Zwar gibt es neuere Entwicklungen wie Deepmind Sima 2, was durchaus in der Lage ist innerhalb von virtuellen Welten zu agieren, doch ist der Tokenverbrauch hoch und es gibt nur wenige Dokumentationen dazu.
Heutige LLM sind durchaus imstande in virtuellen Welten zu agieren. Als Beispiel sei hier eine stichpunktartige Komplettlösung für das Maniac Mansion Point&click adventure gegeben welche durch ein LLM from scratch erzeugt wurde:
Karte 1: Start
Team-Wahl: Empfohlen: Syd oder Razor (Musik-Talent) + Bernard (Technik).
Eingang: Gehe zum Haus. Unter der Fußmatte liegt der Türschlüssel.
Eingangshalle: Benutze Schlüssel mit Haustür. Drinnen: Vorsicht vor Edna oder Weird Ed! Wenn sie kommen, schnell in einen Nebenraum flüchten.
Küche: Gehe nach rechts durch die Tür. Nimm das Fleisch aus dem Kühlschrank und die Getränkedose (für später).
Karte 2: Das Gefängnis & Der Fluchtplan
Trigger: Wenn ein Charakter geschnappt wird, landet er im Kerker.
Ausbruch: Drücke den losen Stein an der Wand (links neben der Tür), um die Tür kurz zu öffnen.
Taktik: Nutze einen Charakter als „Köder“, um die Edisons abzulenken, während die anderen zwei das Haus erkunden.
Wichtig: Speichere oft! Ein falscher Schritt führt zum Game Over.
Karte 3: Die Vorräte im Erdgeschoss
Esszimmer: Nimm die Früchte von der Schüssel.
Speisekammer: Nimm den Glasschneider (hinter der Glasvitrine) und den Saft.
Wohnzimmer: Benutze die Kassette mit dem Kassettenrekorder (wichtig für später, um das Glas zu zerschmettern).
Bibliothek: Öffne die Lampe, um das Zimmer zu erhellen. Nimm den Loseblatt-Katalog.
Karte 4: Weird Eds Zimmer (1. Stock)
Vorsicht: Wenn Ed dich sieht, fliegst du raus.
Ablenkung: Warte, bis Ed sein Zimmer verlässt (um das Paket zu holen) oder nutze die Türklingel an der Haustür, um ihn runterzulocken.
Gegenstand: Nimm den Hamster (nur als Razor/Syd relevant für böse Enden) und das Sparschwein. Brich das Schwein auf, um Geld zu erhalten.
Schlüssel: Nimm den Schlüssel vom Nachttisch.
Karte 5: Das Musikzimmer & Die Glasplatte
Vorbereitung: Geh ins Musikzimmer (1. Stock).
Aktion: Benutze den Glasschneider mit der Vitrine, um die Kassette zu stehlen.
Klavier: Wenn du Razor oder Syd bist, kannst du hier spielen, aber das Ziel ist die Schallplatte im Zimmer daneben.
Tipp: Du musst die Schallplatte auf den Rekorder im Wohnzimmer legen und aufnehmen, um später das Fenster im Labor zu sprengen.
Karte 6: Das Schwimmbad (Außenbereich)
Gefahr: Das Wasser ist radioaktiv! Nicht hineingehen.
Aktion: Leere das Becken, indem du das Ventil im Keller (unter der Küche) benutzt.
Fundstück: Am Boden des leeren Beckens liegt der leuchtende Schlüssel.
Wichtig: Fülle das Becken sofort wieder auf, da sonst der Reaktor überhitzt (Game Over Timer startet!).
Karte 7: Der Grüne Tentakel
Ort: 2. Stock, Weg zum Dachboden.
Problem: Der Grüne Tentakel hat Hunger und lässt dich nicht vorbei.
Lösung: Gib ihm den Obstteller aus dem Esszimmer und den Saft (oder die Cola).
Ergebnis: Er wird dein Freund und lässt dich passieren. Du hast nun Zugang zu den oberen Räumen und dem Funkgerät.
Karte 8: Das Paket & Das Telefon
Paket: Wenn die Türklingel läutet, renne mit einem Charakter zur Haustür und schnapp dir das Paket, bevor Ed es bekommt.
Inhalt: Briefmarken.
Telefon: Benutze das Telefon im Arbeitszimmer. Wähle die Nummer vom „Metzger“ (findest du im Loseblatt-Katalog), um Edna abzulenken.
Nächster Schritt: Während Edna telefoniert, schleiche in ihr Zimmer, um den Schlüssel zum Labor zu finden.
Diese Anleitung gibt in natürlicher Sprache einen Ablauf vor um das Spiel erfolgreich zu spielen. Einziges Problem bei dieser Anleitung ist, dass es kein ausführbarer Computer code ist sondern an menschliche Leser adressiert wurde. In der DIKW pyramide ist die Komplettlösung also auf dem Layer 3 (knowledge) angesiedelt. Damit eine KI Maniac Mansion automatisiert durchspöielen kann, muss man die Anleitung auf eine niedrige DIKW Stufe übersetzen also auf Stufe 2 und Stufe 1 (Daten).
Sowas wird über ein Text to action model realisiert. DAs erhält eine Karteikarte als Input und erzeugt dafür die Mausbewegung als Ausgabe.
Hier die simulierten Mausbewegungen für Karteikarte #1 innerhalb der SCUMM-Engine bei einer Auflösung von 320x200 Pixeln. Das json file enthält dieselben Anweisungen wie die textuelle Komplettlösung auch nur mit dem Unterschied dass es nicht auf dem DIKW layer 3 sondern auf dem untersten Layer 1 angesiedelt ist. Als Folge gibt es numerische Koordinaten die definieren wo genau der Mauscursor hinbewegt wird.
{
"card_id": 1,
"title": "Start",
"steps": [
{
"action_order": 1,
"description": "Walk to the front door area",
"command": "WALK_TO",
"target_coords": {"x": 160, "y": 140},
"wait_ms": 2000
},
{
"action_order": 2,
"description": "Pick up the door mat",
"verb_click": {"x": 40, "y": 170, "label": "PICK_UP"},
"object_click": {"x": 155, "y": 155, "label": "DOOR_MAT"},
"wait_ms": 1500
},
{
"action_order": 3,
"description": "Pick up the key under the mat",
"verb_click": {"x": 40, "y": 170, "label": "PICK_UP"},
"object_click": {"x": 155, "y": 155, "label": "KEY"},
"wait_ms": 1000
},
{
"action_order": 4,
"description": "Use key with front door",
"verb_click": {"x": 80, "y": 180, "label": "USE"},
"inventory_click": {"x": 300, "y": 170, "label": "KEY"},
"object_click": {"x": 160, "y": 100, "label": "FRONT_DOOR"},
"wait_ms": 3000
},
{
"action_order": 5,
"description": "Enter the house",
"command": "WALK_TO",
"target_coords": {"x": 160, "y": 90},
"wait_ms": 2000
},
{
"action_order": 6,
"description": "Go to the kitchen (right door)",
"command": "WALK_TO",
"target_coords": {"x": 280, "y": 120},
"wait_ms": 2500
},
{
"action_order": 7,
"description": "Open refrigerator",
"verb_click": {"x": 40, "y": 180, "label": "OPEN"},
"object_click": {"x": 100, "y": 100, "label": "REFRIGERATOR"},
"wait_ms": 1000
},
{
"action_order": 8,
"description": "Pick up the meat",
"verb_click": {"x": 40, "y": 170, "label": "PICK_UP"},
"object_click": {"x": 105, "y": 110, "label": "MEAT"},
"wait_ms": 1000
}
]
}
March 25, 2026
DIKW database for a warehouse robot
The following DIKW pyramid was simplified to only 2 bottom layers. Its stored in a json database with 2 different tables. The data layer stores the numerical sensor data like lidar_distance and battery voltage of the robot, while the information layer stored semantic tags. The task for the robot is to translate between both layers back and forth which is called symbol grounding.
{
"dikw_model": {
"data_layer": {
"lidar_distance_cm": 12.5,
"ultrasonic_proximity": 0.15,
"camera_rgb_average": [120, 120, 120],
"encoder_ticks": 4502,
"battery_voltage": 11.2
},
"information_layer": {
"spatial_context": ["obstacle", "near_field"],
"navigation_tag": "left_quadrant_blocked",
"surface_type": "concrete",
"status": "low_battery_warning",
"motion_state": "decelerating"
}
}
}
Line breaking algorithm in typst
To investigate if the current quality of typst typesetting fulfills the needs of an academic paper let us benchmark the algorithm for a complex example, which is 3 column typesetting. In a 3 column layout, each column is very small which makes it harder for the algorithm to avoid white spaces between the words.
Of course, there are some white spaces available but in general the output has an average quality. LaTeX would be able to reduce the white spaces by microtypography tricks not available in typst. Its a subjective opinion which of the systems is preferred.
March 24, 2026
Language parsing with a DIKW pyramid
A single sentence can be submitted to the dikw database and the database resolves the request so that it will become machine readable. Going upwards and downwards in the DIKW pyramid is equal to symbol grounding.
A DIKW pyramid consists of layers which are storing different sort of information. The lowest layer is accessible for a computer program and consists of location in a map, trajectories, sprites, tile maps and numerical color information. A possible entry might be [100,30] for a position in a map or (100,120,90) for a RGB color information.
On the next layer "information" a different sort of information are stored which are words. A word is a string which can be understand by a human but doesn't provide sense for a computer. For a human the word "wood" makes sense, but for a computer the same string is only an array of characters without any meaning. Its the task of the DIKW pyramid to link the word "wood" with a location in the map. The link allows the computer to resolve the meaning.
March 23, 2026
Language enabled artificial intelligence
AI resarch in the past was dominated by an algorithm centric bias. The goal was mostly to invent an advanced computer program which simulates intelligence. The idea was inspired by a chess engine which is searching in the game state for the next action. Robotics projects were engineered with the same objective. Notable algorithms are RRT for kinodynimaic planning or genetic algorithm for artificial life.
In the 1990s and until 2000s this paradigm was accepted as state of the art attempt to realize artificial intelligence. Unfortunately. none of the described techniques was successful. The robots are not working and the Artificial life simulation didn't evolve into a life form.
There was something missing until the 2000s for enabling artificial intelligence, and the missing element is natural language. On the first look this explanation doesn't make sense because there are lots of examples for text adventures and language understanding AI projects in the past, so the principle isn't new and can't be the explanation how to realize AI. Typical well known examples from the past are SHDRLU, the Maniac mansion game which was based on a simple 2 word 'English parser and a speech enabled robot from 1989 (SAM by Michael Brown).
The breakthrough technology after 2010 was to focus again on language guided robotics and implement these projects with more effort. Instead of programming a video game like Maniac mansion the goal was to program a text interface for robot control. Instead of realizing the parser in a simple C code, the parser is realized with a neural network. So we can say, that AI after the year 2010 has put natural language into the center of attention and created new algorithms and software around the problem. This attempt was very successful. It is possible to control robots with language and very important its even possible to scale up the approach so that the robot will understand more words and solve more demanding tasks.
From a birds eye perspective the situation until 2010 was to implement closed systems. AI was imagined as an autonomous system which is operating with algorithms and has no need to talk to its environment. In contrast, AI after the year 2010 works as open system. The robot receives commands from the human operator and sends signals back to the operator. In other words, modern robotics is always remote controlled with a text based interface. Its not possible to implement Artificial intelligence somehow else, but text based interaction is the core element of any AI system.
Its only a detail question how to program such an open system in detail. One attempt might be to utilize neural networks and learn the language from a dataset. Another attempt is to program the parser in a classical computer program without neural networks, while the third technique is to invent a domain specific language used for human to robot interaction. All these approaches have in common that natural language is the core building block. Natural language is used as an abstraction mechanism to compress the complex reality into a list of words. A typical entry level robot knows around 200 words to describe the environment including possible actions. These words are used by the robot to interact with a human operator. So the AI problem is mostly a communication problem, similar to transmit messages over a wire.
The paradigm shift from former computation into modern communication is the breakthrough technology for enabling artificial intelligence. Natural language used for human communication is also a powerful tool for human to robot communication. The English vocabulary is seen as a hammer for solving problems. Any problem in robotics gets reformulated into a language problem. There is no limit visible, but all the problems like biped walking, navigation in a maze and pick&place can be reformulated as language games.
Such kind of utilization of natural language wasn't available before the year 2010. The only thing known were isolated projects which explored if language might be useful for robotics. There was no understanding available that natural language is the core element in AI and needs to implemented in any possible robot or AI problem.
March 22, 2026
Instruction following for videogames
The most advanced AI model yet is "Google Sima 2" from the year 2025.[1] The most remarable element isn't the inner working of the agent but its interaction with a human. Its basically a teleoperated video game based on natural language. The human operator enters a command and the AI is translating the text into action.
In other words, the AI itself isn't running a sophisticated algorithm and tries to win any game, but the AI is a text to action converter known as "instruction following". Similar to a large language model the working thesis is, that natural language is the key element for abstract thinking. Describing the next action of character in a videogame in English provides an abstraction mechanism. Instead of mathematical state space used for early chess games based on alpha beta pruning, the "Sima 2" agent utilizes natural language as communication tool.
Of course the input command can be generated by human operators and by large language models both. In the second case the agent will be controlled autonomously like a fully working ingame AI. So the human operator enters only the general command like "win the game" and the large language model will generate all the sub commands and submits them to the Sina 2 agent.
Let me explain the mechanism from a different point of view. Suppose the parser gets removed from the Sina 2 agent so he won't no longer understand natural language. In such a case, the AI can't do anything. It is not able to play the game or solve very simple puzzles. In other words, the intelligence of the AI depends entirely on natural language understanding. The agent needs to know what the term "jump" is about and needs to localize objects like "wall" and "coin" in the game. The software is utilizing the power of English which consists of verbs, adjectives and nouns to interact with videogames.
[1] Bolton, Adrian, et al. "Sima 2: A generalist embodied agent for virtual worlds." arXiv preprint arXiv:2512.04797 (2025).
March 19, 2026
Wissenschaftliche Texte schreiben mit typst
Anstatt hier die technische Bedienung des Textsatzsystems typst zu erläutern, welche gut dokumentiert ist und große Ähnlichkeit mit LaTeX aufweist will ich ein wenig auf die sozialen Aspekte eingehen, wie genau der Switch vom altgedienten Kohledampfer LaTeX auf das neuartige Dieselschiff typst funktioniert.
Zuerst einmal sollte man sich die Mühe machen, LaTeX lebewohl zu sagen was in Linux mit dem Befehl "apt remove textlive-*" funktioniert. Dieser Befehl löscht LaTeX von der Festplatte inkl. der zahlreichen ungenutzten Fonts, der Sprachpakete und der obsoleten Zusatzpakete. Wenn alles reibungslos funktioniert ist es danach nicht länger möglich über die Kommandozeile LaTeX Dokumente ins PDF Format zu kompilieren. Dadurch entsteht ein Bedarf nach einer Lösung die besser ist als gar keine Lösung.
Wenn man dringend eine Abschlussarbeit schreiben muss, aber es keine Software dafür gibt, ist jede Software besser als keine. Dadurch blickt man über eventuelle Schwächen großzügig hinweg. Z.B. gibt es in Typst keinen Knuth plass algorithmus wie bei LaTeX ... machts nichts hauptsache es wird überhaupt ein PDF gerendert. Es ist nur sehr umständlich möglich eine Titelzeile zu erzeugen .. .ist nicht weiter schlimm, hauptsache ist dass irgendwo auf der Seite eine Überschrift auftaucht.
Es macht wenig Sinn typst direkt mit Latex zu vergleichen, weil die Software anders funktioniert. Man wird immer irgendwelche Feinheiten finden in den typst Schwächen hat und die bei LaTeX besser gelöst wurden, nur darum geht es nicht. Entscheidend ist dass man überhaupt Text plus grafiken in eine PDF Datei rendern kann und solange die Schrift nicht kleiner ist als 5 pt und die Bilder irgendwie angezeigt werden ist die Aufgabe erfüllt.
Anstatt auf die Details der Typst Software einzugehen macht es mehr Sinn sich mit den Schwächen des LaTeX Ökosystems zu beschäftigen. Der Sourcecode der TeX engine gilt als Spaghetti code. Er wurde in den 1970er geschrieben und verwendet Rekursion als standardprogrammiertechnik. Die meisten Pakete wie Lamport Tex und Bibtex wurden in den 1990er Jahren erstellt und seitdem nicht mehr verbessert. Es gab mal ein Projekt namens latex3, was aber nie realisiert wurde. Von außen Betrawchtet erinnert LaTeX an einen Commodore 64 im Jahr 1994, wo also eine treue Fangemeinde neue Spiele in Assembler programmierte aber nicht einsehen wollte, dass die Welt eine andere ist. Mitte der 1980er Jahre war der 8bit Heimcomputer von Commodore mal state of the Art technologie, aber Mitte der 1990er Jahre war die selbe Technologie veraltet. Und genau das ist die Ist situation mit LaTeX. Die kompletten 8 GB welche eine texlive installation auf der Festplatte in Beschlag nimmt bestehen aus obsoleten Packages, ungewartetem Code, endlosen Makros und immer weiteren Softwareschichten die keinen Sinn machen.
Um eine wissenschaftliche Arbeit zu erstellen braucht es folgende Features: zweispaltensatz, Tabellen, Einbindung von Bildern, Fließtext, Fußnoten und ein Inhaltsverzeichnis. All das stellt typst bereit. Es gibt sogar noch weitere Extras wie Gleitumgebungen, Silbentrennung und dreispaltensatz. Man kann also sagen, dass typst die Anforderungen übererfüllt. Damit ist es gut geiegnet um damit Texte zu erstellen.
Die software ist schön klein, arbeitet sehr schnell, ist umfassend dokumentiert und es gibt online foren für weitere informationen. Also alles verfügbar was man so braucht. Die geringe Anzahl von Nutzer die typst derzeit nutzen ist kein Nachteil sondern ein Vorteil, damit ist sichergestellt dass jeder neue Nutzer der eine Anfängerfrage stellt begeistert empfangen wird und sofort Hilfestellung erhält.