Microtype simulator in python

 

import pygame
import sys
import math

# Initialize Pygame
pygame.init()
pygame.font.init()

# Constants
WIDTH, HEIGHT = 1100, 780
SCREEN = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Professional Microtype Engine & Layout Simulator")
CLOCK = pygame.time.Clock()

# Palettes
COLOR_BG = (249, 248, 245)       # Premium archival paper
COLOR_TEXT = (35, 35, 35)        # Soft black
COLOR_MARGIN = (230, 90, 90)     # Margin guideline
COLOR_UI_BG = (225, 227, 230)
COLOR_UI_TEXT = (50, 55, 60)
COLOR_SLIDER = (70, 130, 180)
COLOR_ACTIVE = (46, 139, 87)     # SeaGreen for scores/active selections

# Load fonts
try:
    FONT_SIZE = 18
    FONT = pygame.font.SysFont("georgia", FONT_SIZE)
    FONT_BOLD = pygame.font.SysFont("georgia", FONT_SIZE, bold=True)
except:
    FONT = pygame.font.Font(None, FONT_SIZE)
    FONT_BOLD = pygame.font.Font(None, FONT_SIZE)

SAMPLE_TEXT = (
    "Typography is the art and technique of arranging type to make written language "
    "legible, readable, and appealing when displayed. The Knuth-Plass dynamic programming "
    "algorithm revolutionizes this by looking ahead at the entire paragraph. Instead of "
    "making hasty choices on a line-by-line basis, it distributes layout 'badness' evenly, "
    "preventing unexpected blocks of loose text. Combined with microtype tracking expansions, "
    "subtle margin protrusions yield pristine geometric columns resembling classic elite print."
)

# --- UI Widgets ---
class Slider:
    def __init__(self, x, y, w, h, min_val, max_val, start_val, label):
        self.rect = pygame.Rect(x, y, w, h)
        self.min_val = min_val
        self.max_val = max_val
        self.val = start_val
        self.label = label
        self.grabbed = False
        self.update_handle()

    def update_handle(self):
        ratio = (self.val - self.min_val) / (self.max_val - self.min_val)
        hx = self.rect.x + int(ratio * self.rect.w)
        self.handle_rect = pygame.Rect(hx - 5, self.rect.y - 4, 10, self.rect.h + 8)

    def draw(self, screen):
        lbl = FONT.render(f"{self.label}: {self.val:.2f}", True, COLOR_UI_TEXT)
        screen.blit(lbl, (self.rect.x, self.rect.y - 22))
        pygame.draw.rect(screen, (190, 195, 200), self.rect, border_radius=3)
        pygame.draw.rect(screen, COLOR_SLIDER, self.handle_rect, border_radius=3)

    def handle_event(self, event):
        if event.type == pygame.MOUSEBUTTONDOWN:
            if self.handle_rect.collidepoint(event.pos) or self.rect.collidepoint(event.pos):
                self.grabbed = True
        elif event.type == pygame.MOUSEBUTTONUP:
            self.grabbed = False
        elif event.type == pygame.MOUSEMOTION and self.grabbed:
            mx = max(self.rect.x, min(event.pos[0], self.rect.x + self.rect.w))
            rel = (mx - self.rect.x) / self.rect.w
            self.val = self.min_val + rel * (self.max_val - self.min_val)
            self.update_handle()

class RadioSelector:
    def __init__(self, x, y, options):
        self.x = x
        self.y = y
        self.options = options
        self.selected_index = 1 # Default to Knuth-Plass
        self.buttons = []
        
        for idx, opt in enumerate(options):
            bx = x + (idx * 280)
            self.buttons.append(pygame.Rect(bx, y, 20, 20))

    def draw(self, screen):
        lbl_title = FONT_BOLD.render("Line Breaking Algorithm:", True, COLOR_UI_TEXT)
        screen.blit(lbl_title, (self.x, self.y - 25))
        
        for idx, opt in enumerate(self.options):
            rect = self.buttons[idx]
            # Draw outer circle
            pygame.draw.circle(screen, COLOR_UI_TEXT, rect.center, 10, 2)
            # Draw internal selection
            if idx == self.selected_index:
                pygame.draw.circle(screen, COLOR_ACTIVE, rect.center, 6)
            
            lbl = FONT.render(opt, True, COLOR_UI_TEXT)
            screen.blit(lbl, (rect.x + 25, rect.y + 1))

    def handle_event(self, event):
        if event.type == pygame.MOUSEBUTTONDOWN:
            for idx, rect in enumerate(self.buttons):
                # Expanded click zone for user convenience
                click_zone = rect.inflate(150, 10)
                if click_zone.collidepoint(event.pos):
                    self.selected_index = idx
                    return True
        return False

# --- Helper Text Calculation Tools ---
def compute_word_widths(words, font, tracking):
    return [sum(font.size(char)[0] + tracking for char in word) for word in words]

def calc_line_badness(width, test_width, num_gaps, base_space_width, min_space, max_space, ideal_space, is_last=False):
    if num_gaps == 0:
        remaining = width - test_width
        return (remaining ** 2) if remaining >= 0 else 500000
    
    actual_space = (width - test_width) / num_gaps
    
    if actual_space < min_space:
        # Heavily penalize over-compressed lines
        return 100000 + (min_space - actual_space) * 50000
    elif actual_space > max_space:
        # Loose lines
        return int(((actual_space - max_space) ** 2) * 500)
    else:
        # Standard deviation penalty
        badness = int(((actual_space - ideal_space) ** 2) * 100)
        if is_last and actual_space > ideal_space:
            return 0 # Last line of a paragraph shouldn't stretch to fill the margin
        return badness

def apply_protrusion(word, font, protrusion):
    protruding_chars = [".", ",", "-", "!", "?"]
    if protrusion > 0 and word[-1:] in protruding_chars:
        return font.size(word[-1:])[0] * protrusion * 0.5
    return 0

# --- Line-Breaking Core Algorithms ---

def layout_greedy(words, word_widths, font, width, min_space, max_space, ideal_space, protrusion):
    """ a) Traditional First-Fit Greedy Algorithm """
    lines = []
    current_line, current_widths = [], []
    current_width = 0
    
    for idx, word in enumerate(words):
        w_width = word_widths[idx]
        p_adjust = apply_protrusion(word, font, protrusion)
        
        # Test if it fits with standard spaces
        test_w = current_width + w_width + (ideal_space if current_line else 0) - p_adjust
        if test_w <= width or not current_line:
            current_line.append(word)
            current_widths.append(w_width)
            current_width += w_width + (ideal_space if len(current_line) > 1 else 0)
        else:
            # Seal line
            num_gaps = len(current_line) - 1
            last_word_pad = apply_protrusion(current_line[-1], font, protrusion)
            pure_width = sum(current_widths)
            
            space_used = (width - (pure_width - last_word_pad)) / num_gaps if num_gaps > 0 else ideal_space
            badness = calc_line_badness(width, pure_width - last_word_pad, num_gaps, ideal_space, min_space, max_space, ideal_space)
            
            lines.append((current_line, current_widths, space_used, False, badness))
            current_line, current_widths = [word], [w_width]
            current_width = w_width
            
    if current_line:
        num_gaps = len(current_line) - 1
        last_word_pad = apply_protrusion(current_line[-1], font, protrusion)
        pure_width = sum(current_widths)
        space_used = ideal_space
        badness = calc_line_badness(width, pure_width - last_word_pad, num_gaps, ideal_space, min_space, max_space, ideal_space, is_last=True)
        lines.append((current_line, current_widths, space_used, True, badness))
        
    return lines

def layout_knuth_plass(words, word_widths, font, width, min_space, max_space, ideal_space, protrusion):
    """ b) Look-Ahead Optimization (Global Minimum Variance) """
    n = len(words)
    dp = [(float('inf'), -1, ideal_space, 0)] * (n + 1)
    dp[0] = (0, -1, ideal_space, 0)
    
    for i in range(n):
        if dp[i][0] == float('inf'): continue
        current_width = 0
        for j in range(i, n):
            current_width += word_widths[j]
            num_gaps = j - i
            is_last = (j == n - 1)
            
            p_adjust = apply_protrusion(words[j], font, protrusion)
            line_txt_w = current_width - p_adjust
            
            badness = calc_line_badness(width, line_txt_w, num_gaps, ideal_space, min_space, max_space, ideal_space, is_last)
            
            actual_space = ideal_space
            if num_gaps > 0 and not is_last:
                actual_space = (width - line_txt_w) / num_gaps

            p_cost = dp[i][0] + badness
            if p_cost < dp[j + 1][0]:
                dp[j + 1] = (p_cost, i, actual_space, badness)

    lines, curr = [], n
    while curr > 0:
        parent = dp[curr][1]
        if parent == -1: break
        is_last = (curr == n)
        lines.append((words[parent:curr], word_widths[parent:curr], dp[curr][2], is_last, dp[curr][3]))
        curr = parent
    lines.reverse()
    return lines

def layout_first_fit_tight(words, word_widths, font, width, min_space, max_space, ideal_space, protrusion):
    """ c) Alternating Minimum Space Greedy Algorithm """
    # This variant forces as many words onto the line as physically allowed by compressing down to min_space limits.
    lines = []
    current_line, current_widths = [], []
    
    for idx, word in enumerate(words):
        w_width = word_widths[idx]
        current_line.append(word)
        current_widths.append(w_width)
        
        p_adjust = apply_protrusion(word, font, protrusion)
        num_gaps = len(current_line) - 1
        min_needed = sum(current_widths) + (num_gaps * min_space) - p_adjust
        
        if min_needed > width and num_gaps > 0:
            # Overfilled line, dump the last token to the next row
            popped_word = current_line.pop()
            popped_width = current_widths.pop()
            
            num_gaps = len(current_line) - 1
            last_word_pad = apply_protrusion(current_line[-1], font, protrusion)
            pure_width = sum(current_widths)
            
            space_used = (width - (pure_width - last_word_pad)) / num_gaps if num_gaps > 0 else ideal_space
            badness = calc_line_badness(width, pure_width - last_word_pad, num_gaps, ideal_space, min_space, max_space, ideal_space)
            
            lines.append((current_line, current_widths, space_used, False, badness))
            current_line, current_widths = [popped_word], [popped_width]
            
    if current_line:
        num_gaps = len(current_line) - 1
        last_word_pad = apply_protrusion(current_line[-1], font, protrusion)
        pure_width = sum(current_widths)
        badness = calc_line_badness(width, pure_width - last_word_pad, num_gaps, ideal_space, min_space, max_space, ideal_space, is_last=True)
        lines.append((current_line, current_widths, ideal_space, True, badness))
        
    return lines

# --- Rendering ---
def render_paragraph(lines, font, x_start, y_start, tracking, protrusion, leading_ratio):
    y = y_start
    line_height = int(font.get_linesize() * leading_ratio)
    
    for line_words, line_widths, space_width, is_last, _ in lines:
        x = x_start
        num_words = len(line_words)
        
        for w_idx, word in enumerate(line_words):
            for c_idx, char in enumerate(word):
                char_surf = font.render(char, True, COLOR_TEXT)
                render_x = x
                if w_idx == num_words - 1 and c_idx == len(word) - 1:
                    render_x += apply_protrusion(word, font, protrusion)

                SCREEN.blit(char_surf, (render_x, y))
                x += char_surf.get_width() + tracking
            
            if w_idx < num_words - 1:
                x += space_width
        y += line_height

# --- UI Layout ---
sliders = [
    Slider(50, 540, 260, 10, -1.5, 3.0, 0.0, "Font Expansion (Tracking)"),
    Slider(380, 540, 260, 10, 0.4, 1.0, 0.65, "Min Word Space Elasticity"),
    Slider(710, 540, 260, 10, 1.0, 3.0, 1.70, "Max Word Space Elasticity"),
    Slider(50, 620, 260, 10, 0.0, 1.2, 0.5, "Character Protrusion"),
    Slider(380, 620, 260, 10, 0.8, 2.5, 1.3, "Line Height (Leading)")
]

algo_radio = RadioSelector(50, 710, ["a) Greedy Algorithm", "b) Knuth-Plass Ahead", "c) Space-Tight Fit"])

MARGIN_LEFT = 200
BOX_WIDTH = 700

# Main loop
while True:
    SCREEN.fill(COLOR_BG)
    
    # Event Engine Loop
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
        for slider in sliders:
            slider.handle_event(event)
        algo_radio.handle_event(event)

    # Drawing background infrastructure boundaries
    pygame.draw.rect(SCREEN, COLOR_UI_BG, (0, 480, WIDTH, HEIGHT - 480))
    pygame.draw.line(SCREEN, (190, 195, 200), (0, 480), (WIDTH, 480), 2)
    
    pygame.draw.line(SCREEN, COLOR_MARGIN, (MARGIN_LEFT, 75), (MARGIN_LEFT, 450), 1)
    pygame.draw.line(SCREEN, COLOR_MARGIN, (MARGIN_LEFT + BOX_WIDTH, 75), (MARGIN_LEFT + BOX_WIDTH, 450), 1)

    # Gather metrics
    base_space_width = FONT.size(" ")[0]
    tracking_val = sliders[0].val
    min_space = base_space_width * sliders[1].val
    max_space = base_space_width * sliders[2].val
    protrusion_val = sliders[3].val
    leading_val = sliders[4].val

    # Re-tokenize and check widths inside runtime
    words = SAMPLE_TEXT.split(" ")
    word_widths = compute_word_widths(words, FONT, tracking_val)

    # Route processing via radio flag selections
    if algo_radio.selected_index == 0:
        computed_lines = layout_greedy(words, word_widths, FONT, BOX_WIDTH, min_space, max_space, base_space_width, protrusion_val)
    elif algo_radio.selected_index == 1:
        computed_lines = layout_knuth_plass(words, word_widths, FONT, BOX_WIDTH, min_space, max_space, base_space_width, protrusion_val)
    else:
        computed_lines = layout_first_fit_tight(words, word_widths, FONT, BOX_WIDTH, min_space, max_space, base_space_width, protrusion_val)

    # Cumulative Badness Score Calculation
    total_paragraph_badness = sum(line[4] for line in computed_lines)

    # Render Paragraph Blocks
    render_paragraph(computed_lines, FONT, MARGIN_LEFT, 95, tracking_val, protrusion_val, leading_val)

    # Render Widgets
    for slider in sliders:
        slider.draw(SCREEN)
    algo_radio.draw(SCREEN)

    # Display Badness score at the top panel
    score_lbl = FONT_BOLD.render(f"Overall Paragraph Badness Score: {total_paragraph_badness}", True, COLOR_ACTIVE)
    SCREEN.blit(score_lbl, (MARGIN_LEFT, 35))

    pygame.display.flip()
    CLOCK.tick(30)

Die goldene Zeit von LaTeX

 Die Goldene Zeit des Textsatzsystems liegt weit in der Vergangenheit. LaTeX war zumindest früher eine lebendige Community die aktuelle Technologie nutzte. Man kann diese Zeit im Jahr 1995 verorten. Damals gab es noch kein pdflatex sondern eine DVI Datei wurde mittels dvips nach postscript konvertiert. Anders als heute war dieser Workflow standardisiert, das heißt 99% der Anwender erstellten auf diese Weise ein wissenschaftliches Buch und es gab auch nur das eine LaTeX2e System mit einer kleinen Zahl von Zusatzpackages.

Eine typische tetex installation aus dieser Zeit beanspruchte 150 MB auf Festplatte. Im universitären Umfeld wurden meist SUN Sparcstation Maschinen genutzt auf denen LaTeX inkl. der benötigten Schriften verwendet wurde. Das erwähnte LaTeX2e war damals in 1995 gerade frisch veröffentlicht worden und vereinheitlichte den früheren Wildwuchs. Dadurch wurde LaTeX zum führenden Publishing Werkzeug bei Naturwissenschaftlern und wissenschaftlichen Zeitschriften.

Die schlechte Nachricht lautet, dass diese goldene Zeit viele Jahrzehnte zurückliegt. Seit damals ging die Qualität von LaTeX merklich zurück. Das System, also LaTeX2e mitsamt dvips, ist noch die selbe Software allerdings ist die Welt heute eine andere. Latex ist auf dem alten Stand von 1995 stehengeblieben, seitdem gab es keine wirkliche Innovation mehr. Rein formal wurden zwar Erweiterungen entwickelt wie context, pdflatex und lualatex, doch nicht alle Anwender nutzen diese und einen erkennbaren Vorteil gibt es auch nicht.

Kritik an LaTeX

 Die Typst software ist umfassend online dokumentiert, ist technisch ausgreift und eignet sich hervorragend zum wissenschaftlichen Satz. Da der marketshare von typst bisher kleiner ist als 0.1% dauert es wohl noch einige Jahre bevor das Thema für eine größere Personenzahl relevant wird. Diese Zeit kann man nutzen um das Gegenmodell LaTeX einer kritischen Würdigung zu unterziehen.

Anstatt auf die Anfänge von TeX einzugehen die in den späten 1970er Jahre liege wo bekanntlich Unix Gurus mit Magnetbändern auf DEC Minicomputers gearbeitet haben, macht es Sinn LaTeX in der Gegenwart zu betetrachten. Leider sieht es bei den Detail gar nicht gut aus. Zum einen fällt auf, was alles nicht geht mit LaTeX:

- dreispaltensatz ist nur mit zusatzpaketen möglich
- überhaupt benötigt man für alles mögliche ein package, sei es das einbinden von Grafiken, das Anzeigen von Sourcecode oder das Setzen von Tabellen
- ein Export nach HTML ist nicht möglich nur über weitere pakete oder gar pandoc funktioniert es 
- Die Tex engine ist eingefroren und wird nicht mehr verbessert, bisherige versuche einen LaTeX nachfolger zu entwickeln wie context oder Latex3 sind gescheitert
- großes repository mit veralteten Paketen
- Community ignoriert sachliche Kritik

Schwächen von LaTeX werden nicht behoben sondern sie werden als historisch determiniert wahrgenommen. So ist z.B. die unfähigkeit von LaTeX eine HTML Datei zu erstellen damit zu ekrlären dass es Ende der 1970er als Donald Knuth die erste Version in Turbo Pascal programmiert hat, noch kein HTML gab. Wenn jetzt ein neuling aber genau diese Funktion benötigt wird diesem User geraten lieber auf MS Word umzusteigen weil er keine Einsicht zeigt in die Philosophie von TeX.

Ein solches Ökosystem kann man getrost als statisch bezeichnen. So ähnlich wie die TeX engine im Jahr 1990 eingefroren wurde ist auch die heutige LaTeX Community wie ein Eisblock unbeweglich. Es gibt dafür keine sachlichen Gründe sondern der status quo aus früheren Zeit soll unverändert bleiben. Wie bei Sekten steigt dadurch die Entropie an. Entropie ist ein Maß für das Chaos was innerhalb der LaTeX Community nicht abgebaut werden kann. Man kann das sogar messen und zwar an der Zahl der benötigten megabyte die texlife auf der Festplatte benötigt.

1990, 10 MB
2000, 100 MB
2010, 800 MB
2020, 2 GB
2026, 2.8 GB

Selbst für aktuelle high end PC die mit SSD als Festplattenersatz arbeiten ist die installation und das update einer LaTeX Installation ein Großprojekt. Es müssen unzählige Einzeldateien heruntergeladen werden und die chance dass dabei Fehlermeldungen entstehen ist hoch. Technisch gesehen müsste jemand die Software modernisieren, also nicht benötigte Pakete entfernen, die Engine neu programmieren usw. Es gab mehrmals diese Versuche die jedoch gescheitert sind, zuletzt wurde das Luatex projekt gestartet. In der Praxis nutzen die meisten User jedoch das ältere pdflatex, weil das schneller eine PDF Datei erzeugt. Leider sind damit die Modernisierungen von Luatex hinfällig und die Entropie steigt weiter.

Es gab mehrere Versuche LaTeX zu modernisieren:
- LaTex3
- Omega
- ConTeXt
- LaTeX2HTML
- LuaTeX
- Overleaf

Jedes Projekt hat schwächen und wird von der Community kritisiert. Das hatte zur Folge dass viele Parallel projekte entstanden mit unterschiedlichen Zielsetzungen.

Kurzbericht zu typst 0.15

 Seit Juni 2026 ist das Textsatzsystem typst in der neuen Version 0.15 verfügbar. Die Installation gestaltet sich so dass man eine ausführbare Datei herunterlädt welche entpackt rund 55 MB groß ist. verglichen mit pdflatex was in Linux rund 2 GB benötigt ist das sehr wenig Speicher. Trotzdem haben die Entwickler es erneut geschafft mit dieser einzigen Datei alle wichtigen Gebiete abzudecken die man von einem LaTeX Nachfolger erwartet:

- 2 spalten satz
- blocksatz
- unterschiedliche Schriftarten
- automatische Inhaltsverzeichnisse
- Tabellen
- Bilder in unterschiedlichen Formaten wie jpg, svg, png usw.

Ehemalige LaTeX Nutzer werden bemerken, dass die typst Syntax deutlich einfacher zu verwenden ist. Es gibt wenig bis gar keine Zusatzpakete die man einbinden muss sondern alle wichtigen Funktionen sind in der ausführbaren typst Datei enthalten. Es reicht aus, einmalig sich in das Program einzuarbeiten, ein wenig mit float figures und Tabellensatz herumzuprobieren und schon kann man umfangreiche wissenschaftliche oder sonstige Dokumentationen erstellen. Die Lernkurve ist deutlich flacher als bei LaTeX, die Ausgabequalität ist vergleichbar hoch.

Typst füllt damit ein Lücke die frühere Linux Kommandozeilen tools wie asciidoc, pandoc oder HTML hinterlassen haben. Es ermöglicht die Erstellung von Dokumenten in einem Texteditor und ist damit weitaus besser für umfangreiche Texte geeignet als Libreoffice.

Die Zielgruppe von typst sind zweifelsfrei frühere LaTeX user, diese zu überzeugen auf die neue Software umzusteigen ist die größte Hürde. LaTeX ist bekanntlich ein sehr mächtiges Ökosystem was über Jahrzehnte gewachsen ist. Viele LaTeX User empfinden typst als Rückschritt, gerade weil es leichter zu benutzen ist und die Einstiegshürde senkt. Man muss weder mit dem troff System aus Unix vertraut sein, noch muss man eine rekursive Makrosprache lernen, sondern typst ist ähnlich wie Markdown für ein großes Zielpublikum entwickelt worden.

Vielleicht ein kleines Textbeispiel. Zuerst LaTeX:

\begin{enumerate}
  \item erstes 
  \item zweites 
\end{enumerate}

dann typst:

1. erstes
2. zweites

Hier noch ein Beispiel zum Einbinden einer Grafik. Zuerst LaTeX:

\usepackage{graphicx}
\begin{figure}
  \includegraphics{lion.png}
\end{figure}
  
dann typst:

#figure(
  image("lion.png", width: 6cm),
  caption: [Lion],
)

Wenn man sich zusätzlich noch die Compilergeschwindigkeit anschaut mit der typst umfangreiche Dokumente inkl. Abbildungen in eine PDF Datei ausgibt so dürfte die LaTeX Community es schwer haben mit Argumenten zu überzeugen. Was bleibt ist die Tatsache, dass LaTeX das ältere und etablierte System ist während typst in einer frühen Version daherkommt und bisher nur selten praktisch angewendet wird.

Head up display with inner voice for a kitchen robot in pixelart

Haushaltsroboter in den 1980er Jahren

 Zeitgleich zum Aufstieg der 8bit Heimcomputer in den 1980er gab es eine kurze Blütezeit für Haushaltsroboter. Die verkaufte stückzahl war sehr gering, und es wurde nie ein Massenprodukt. Dennoch wurden Mitte der 1980er einige frühe Roboter herstellt wie:

- Hero 24kb ram, intel 8088 cpu
- Arctec gemini, mit 100 kb RAM
- Androbot B.O.B.

Verbaut wurde damalige state of the art technologie, also 8bit CPU, ein sehr kleiner RAM und häufig BASIC ähnliche Programmiersprachen im ROM. Anders als die sehr erfolgreichen Heimcomputer von Atari und Commodore hatten die obigen Roboter keinen sinnvollen Verwendungszweck. Sie konnten zwar durch servomotoren auf dem Teppich herumfahren aber bereits die selbstlokalisierung funktioniert nicht und das greifen von Gegenständen war nur mittels Fernsteuerung möglich.

Man kann anhand dieser frühen Roboter gut erkennen warum Künstliche Intelligenz sich in den späten 1980er Jahren in einer Sackgasse befand. Und zwar weil die damals verfügbare Hard- und Software keinerlei praktische Anwendungsmöglichkeiten hatte.

Konträr dazu konnten dezidierte Heimcomputer wie der berühmte Commodore 64 oder der Apple II sehr variable verwendet werden. Man konnte damit Spiele spielen, man konnte Programmieren lernen, man konnte kurze Texte eintippen und man konnte Grafiken auf dem Bildschirm zeichnen.

Das eigentliche Problem mit den Robotern aus den 1980er war weniger ihre schlechte Hardwareausstattung sondern die Frage wie man die Funktionen des Roboter hochskalieren sollte. Also wie aus einem klobigen Plasteeimer eine intelligente Maschine wird, die eigenständig Entscheidungen trifft.

Diese Frage wurde gestellt, aber es hatte niemand eine Antwort darauf. Künstliche INteligenz war zwar als Begriff vorhanden aber es war unklar wie man diese technisch erreicht.

Im Jahr 2026 gibt es eine Antwort auf das KI Problem und zwar benötigt man ein Speaker hearer language game. Durch ein Sprachspiel mit verteilten Rollen lässt sich menschliches Denken auf zwei Stellen aufteilen und dadurch maschinell zugänglich machen. Zwar konnte 

Technisch hatte der Arctec gemini Roboter aus dem Jahr 1985 eine eingebaut "voice/speech recognition" war also in der Lage einen natürlichsprachlichen Dialog mit Menschen zu führen. Allerdings wurde dieses Feature zur damaligen Zeit nicht als Kernbestandteil der Künstlichen Intelligenz betrachtet. Die Annahme in den 1980er und teilweise bis in die 2000er Jahre lautete, dass Künstliche Intelligenz innerhalb eines Roboters verortet sei, also ein Algorithmus sei der von der CPU ausgeführt wird.

Die moderne KI Forschung sieht das grundsätzlich anders. Danach ist künstliche Intelligenz ein Kommunikationsmuster bei dem Nachrichten von A nach B übertragen werden. Es wird also nichts berechnet sondern es wird eine Nachricht befördert. Sobald man Künstliche Intelligenz als Nachrichtenübermittlung betrachtet kann man die Leistung hochskalieren. Man beginnt mit einem sehr einfachen Sprachspiel was man als computerprogram implementiert, z.B. "Hol das Objekt". Der speaker sagt einen Begriff wie "Ball" und der Hearer muss das objekt finden und einsammeln.

Die nächste Stufe wäre das Sprachspiel etwas komplexer zu gestalten, also die Anzahl der Worte erhöhen, und neben "hol" weitere Aktionswörter zu verwenden.

Das Nachrichten-basierte Verständnis von Künstlicher Intelligenz hat sich in der Informatik sehr spät durchgesetzt. Erst ab dem Jahr 2023 mit der Entwicklung von LLM Sprachmodellen wird Künstliche Intelligenz gleichgesetzt mit Mensch maschine interaktion. Der Mensch formuliert einen Text-Prompt, welcher von der Maschine durch ein Sprachmodell beantwortet wird. Je mehr anfragen ein Sprachmodel versteht und bearbeitet desto leistungsfähiger ist die Künstliche Intelligenz.

Das Hochskalieren von Künstlicher Intelligenz ab dem Jahr 2023 erfolgt durch immer komplexer werdende Benchmarks. Die ersten Datasets welche durch neuronale Netze bearbeitet wurden bestanden aus simplen Frage/Antwort paaren. Der speaker stellt eine Frage "Was ist die Hauptstadt von Groß Britanien?" und der Hearer muss die richtige Antwort sagen "London". Zunächst waren diese Datasets eingeschränkt auf eine einzige Domäne, also nur geographie Kenntnisse, nur Mathematik-Kenntnisse. Später begann man universal Datensätze zu nutzen wo also unterschiedliche Wissensgebiete mit einer Punktezahl abgefragt wurden.

Die nächste Stufe in der Entwicklung Künstlicher Intelligenz bestand damit weiter interaktionen ausführen, das also der Datensatz Bilder und Töne enthielt. Die interaktion bestand jetzt darin dass der Speaker eine Aufgabe stellt wie "Male ein Bild mit einem Sonnenaufgang" und der Hearer musste dazu das passende Bild erstellen. Anschließend wurde begonnen die Schwierigkeit weiter zu erhöhen. Neuere Benchmarks enthalten komplexe Aufgabenstellungen wo also komplette Texte erzeugt werden oder umfangreiche tabellen formatiert werden. Auch diese Aufgaben werden interaktion über speaker to hearer kommunikation realisiert.

Kurzgeschichte: Robotersteuerung mit genetischen Algorithmen

Überall summen leise Motoren. An den Wänden hängen Monitore mit endlosen Datenströmen. In der Mitte des Raums steht ein eleganter, humanoider Roboter, der fehlerfrei Porzellantassen von einer Spülmaschine in einen Oberschrank räumt. Li Wei, ein Austauschstudent aus Peking, beobachtet die Szene fasziniert, ein digitales Notizbuch fest in der Hand. Dr. Elena Brandt, die leitende Forscherin, tritt zu ihm.

Dr. Brandt: (lächelt) Faszinierend, nicht wahr? Er hat seit heute Morgen nicht eine einzige Tasse fallen gelassen. Willkommen in unserem Labor, Li Wei.

Li Wei: (verneigt sich leicht) Vielen Dank, Frau Dr. Brandt. Es ist mir eine große Ehre, hier zu sein. Die flüssigen Bewegungen dieses Modells... das ist die neue Generation des Domestic-Helper-2000, richtig? Ich habe Ihre Veröffentlichungen gelesen, aber die Realität übertrifft alles. Die Trajektorienplanung muss unglaublich präzise sein. Läuft das über ein klassisches neuronales Netz?

Dr. Brandt: (schüttelt den Kopf) Nein, tatsächlich nicht mehr. Das war die letzte Generation. Was Sie hier sehen, ist ein völlig neuer Ansatz für die Echtzeit-Adaption. Die Steuerung dieses humanoiden Haushaltsroboters basiert auf genetischen Algorithmen.

Li Wei: (stutzt, die Augen weiten sich) Genetische Algorithmen? Für die direkte Motorsteuerung eines Humanoiden? Das... das ist ein mathematisches Optimierungsverfahren, oder?

Dr. Brandt: Genau. Wir nutzen die Prinzipien der biologischen Evolution – Selektion, Kreuzung und Mutation –, um die optimalen Bewegungsmuster für unvorhergesehene Haushaltsbzw. Alltagssituationen zu finden.

Li Wei nickt eifrig und beginnt sofort, handschriftliche Notizen auf seinem Tablet zu machen. Seine Augen leuchten vor akademischer Neugier.

Li Wei: (schreibt schnell) Evolutionäre Strategien im Haushaltsbereich... Aber Frau Doktor, genetische Algorithmen sind doch extrem rechenintensiv! Um eine Population von potenziellen Bewegungspfaden zu generieren, ihre Fitness zu bewerten und sie über Generationen hinweg zu optimieren... das braucht doch astronomisch viel CPU-Leistung?

Dr. Brandt: (seufzt hörbar) Da haben Sie den wunden Punkt getroffen. Sie sind gut informiert. Ja, der Heißhunger auf CPU-Leistung ist gigantisch. Schauen Sie mal hier rüber.

Sie geht zu einem gläsernen Schaltschrank in der Ecke des Labors. Darin leuchten blaue LEDs, und das Rauschen von Hochleistungs-Lüftern ist permanent im Hintergrund zu hören.

Dr. Brandt: Das ist unsere Recheneinheit. Der Roboter selbst trägt nur die Sensorik und die Aktuatoren. Die eigentliche „Evolution“ der Algorithmen findet auf diesem lokalen Edge-Server statt. Für die Fitnessfunktion müssen wir in Millisekunden berechnen, wie stabil der Roboter steht, wie viel Drehmoment auf die Gelenke wirkt und ob die Tasse ganz bleibt. Das zwingt selbst modernste Multi-Core-Prozessoren in die Knie.

Li Wei: (schreibt verbissen mit) „Lokaler Edge-Server notwendig... Extreme Last auf Multi-Core-CPUs... Fitnessfunktion berechnet Stabilität, Drehmoment und Objektschutz in Echtzeit...“

Li Wei blickt von seinem Tablet auf.

Li Wei: Aber wie lösen Sie das Latenzproblem? Wenn der Roboter stolpert, kann er doch nicht erst zweihundert Generationen an Algorithmen abwarten, bis die CPU die optimale Ausgleichsbewegung berechnet hat?

Dr. Brandt: Ausgezeichnete Frage. Wir nutzen ein hybrides System. Für den absoluten Notfall – also das Stolpern – greift ein klassisches, schnelles Hardwaresystem. Aber für die Optimierung des Greifens, das Ausweichen von Haustieren oder das Umorganisieren einer chaotischen Küche nutzen wir die genetische Optimierung. Der Roboter „probt“ die Bewegung quasi tausendfach im virtuellen Raum der CPU, bevor er den Arm auch nur einen Zentimeter bewegt. Die „fitteste“ Lösung gewinnt.

Li Wei: (murmelt, während er tippt) Virtuelles Proben... Evolutionäre Selektion vor der physischen Ausführung... Das bedeutet, der Roboter lernt permanent und individuell in jeder neuen Wohnung?

Dr. Brandt: Exakt. Jeder Haushalt ist anders. Ein starrer Algorithmus scheitert an Kleinigkeiten. Unsere genetischen Algorithmen passen sich an die spezifische Umgebung an. Nach ein paar Tagen hat die CPU die perfekte „DNA“ für die Interaktion mit den Möbeln des Besitzers gezüchtet.

Li Wei: Das ist genial, aber der Energieverbrauch muss durch die CPU-Auslastung enorm sein. Für den kommerziellen Massenmarkt in China oder hier in Europa ist das Design so doch noch schwer zu skalieren, oder?

Dr. Brandt: Da haben Sie völlig recht. Das ist unsere aktuelle Forschungsfrage: Wie komprimieren wir diese mathematische Optimierung, ohne die Evolutionsqualität zu verlieren? Wenn Sie Ihre Masterarbeit bei uns schreiben, könnten Sie genau an dieser Schnittstelle forschen.

Li Wei hält inne. Er blickt auf seine Notizen, dann auf den Roboter, der gerade die letzte Tasse perfekt platziert hat, und schließlich zu Dr. Brandt. Ein breites Lächeln breitet sich auf seinem Gesicht aus.

Li Wei: Frau Dr. Brandt... das wäre mir eine absolute Ehre. Ich glaube, ich habe gerade mein Traum-Forschungsthema gefunden.

Das Grounding Problem in der Geschichte der KI

 In der Geschichte der Künstlichen Intelligenz gab es zwei wesentlichen Ansätze zur Wissensmodellierung: einmal die symbolische KI die in der Frame Theory ihren Höhepunkt fand und bei der Wissen als Objekte abgelegt werden die untereinander kommunizieren und zweitens die Programmiersprachen angefangen von C/C++ als Systemprogrammiersprachen bis hin zu modernen KI Sprachen wie LISP und Prolog welche beide das Speichern von Wissen unterstützen.

Leider gibt es mit diesen Ansätzen ein Problem: es skaliert nicht. Will man ein konkretes Problem lösen z.b. eine Robotersteuerung entwickeln wird man mit Frames, Lisp, Prolog oder semantischen Netzen keinen Erfolg haben. Woran es mangelt ist die praktische Relevanz. Selbst für Triviale Probleme wie towers of honoi ist es extrem schwer eine Implementierung in Prolog oder als Frames zu realisieren. Man kann also unterstellen, dass die Künstliche Intelligenz in einer Sackgasse ist.

Diese Sackgasse wird deutlich sobald man versucht einem Computer das denken einzuprogrammieren. Mag das Schreiben eines normalen Computerprograms in C/C++ noch halbwegs lösbar sein, ist das Einprogrammieren von Faktenwissen in eine Maschine eine unlösbare Aufgabe. Wichtig ist zu wissen dass selbst weiterentwickelte Konzepte wie agentenbasierte Programmiersprachen oder Web 2.0 Semantiken welche die Frame Theorie weiterentwickelt haben nicht zu erfolg führen.

Es ist gut nachvollziehbar warum Anfang der 1990er Jahre die Künstliche Intelligenz Forschung wiedereinmal für gescheitert erklärt wurde. Die ursache liegt darin wie in der Nicht KI Informatik Software entwickelt wird nähmlich um sie auf einer CPU auszuführen. Die Vorstellung der Programmierer lautet, dass ein Spiel oder eine Datenbank auf einer konkreten CPU ausführbar ist, entweder als direkte Assembler routine oder als imperative Programmiersprache die mittels Compiler in Assembler code konvertiert wird. Vorhandene Bibliotheken die grafikroutinen oder Hardwaretreiber enthalten sind ebenfalls mit dieser Zielstellung entwickelt worden. Man kann sagen, dass Softwareentwicklung immer prozessororientiert funktioniert.

Dieses Konzept ist ungeeignet für die Erstellung von KI Applikationen, das war jedoch den Forschern Anfang der 1990er Jahre nicht bekannt. Sie unterstellten, dass KI Anwendungen ebenfalls prozessororientiert erstellt werden könnten. So wurden mit viel Aufwand KI Programmiersprachen und sogar KI Softwarebibliotheken erstellt in der wagen HOffnung das man dieses Konzept hochskalieren könnte zu leistungsfähigeren Anwendungen.

Das Gegenmodel zu einer computational approach ist ein Kommunikationsparadigma das erstaunlicherweise sogar in der klassischen Informatik diskutiert wird. Überall dort wo Computernetzte gebildet werden liegt der Fokus auf dem Datenbus und nicht auf der Einzel-CPU. Diese Kommunikationsorientierte Perspektive kann auf die Künstliche Intelligenz und Robotik übertragen werden und hilft dabei intelligente Maschinen zu entwickeln. Anstatt zu diskutieren welcher Algorithmus und welche Programmiersprache benötigt wird, lautet die neue Fragestellung welches Protokoll sinnvoll ist und wie Daten übertragen und geparst werden müssen.

Betrachten wir beide Konzepte im direkten Verrgleich um die Unterschiede zu verdeutlichen. Die klassische CPU orientierte Sichtweise fokussiert auf einen Einzelcomputer und versucht für die dort vorhandene CPU Software zu erstellen. Die Idee ist dass die CPU die Software ausführt und daraufhin eine 2d Grafik auf den Bildschirm zeichnet oder eine Datenbank durchsucht. Umgekehrt liegt bei einer Kommunikationsorientierte Sichtweise der Fokus auf dem Bus, also dem Kabel zwischen zwei Computern. Dieses Kabel ist entweder als phyissches Koaxial Kabel, als Lichtwellenleiter oder sogar als Airgap bei Wifi realisiert und enthält weder eine CPU noch eine Datenspeicher, sondern ein Kabel ist ein Medium über das Daten überrragen werden. Man kann für einen Bus auch keine Software schreiben im traditionellen  Sinne sondern man kann lediglich Protokolle erfinden die zur Kommunikation verwendet werden.

Sämtliche Entwicklungen der Künstlichen Intelligenz ab dem Jahr 2020 wie Question/answering Pairs, motion capture annotation, Speaker Hearer interaction, Vision language modelle können als Kommunikation zwischen zwei Systemen verstanden werden. Immer wird von einerm Sender an einen Receiver ein Datenpaket übertragen. im Fall einer Question answer challenge ist das Datenpaket eine Frage auf die der receiver mit einem Datenpaket antwortet während bei einem Instruction following task der sender einen Befehl sendet welcher vom receiver ausgeführt wird. Es gibt also nicht eine CPU die ein Program ausführt, sondern es gibt immer zwei instanzen zwischen denen Daten übertragen werden.

Damit verlagert sich der Fokus weg von der internen Funktionsweise eines Computers hin zu offenen Systemen die mit ihrer Umwelt interagieren. Wie diese Systeme intern arbeiten ist zweirangig.