Eine Treppe ist eine Ziffer. Vor dem Gelander, dem Nasenlaufkanten-Detail oder der Eiche-gegen-Terrazzo-Debatte legt jemand die Stufenanzahl n fest, und alles andere folgt daraus. Die Stufenhohe ist die Geschosshohe geteilt durch n: s = H/n. Die Stufentiefe kommt aus einer Schrittformel des 17. Jahrhunderts. Zwei Stufen plus eine Stufentiefe ergeben einen menschlichen Schritt, 2s + a = 63 cm, daher a = 63 cm − 2s. Nach Baunetzwissen hat François Blondel die Regel in seinem Cours d’architecture niedergeschrieben; das Werk kam in Teilen heraus, daher geben Quellen 1675 oder 1683 fur die Regel an. In jedem Fall hat sie jedes Zeichenprogramm uberdauert, das je zu ihrer Anwendung gebaut wurde.

Die Schweizer Regelwerke ersetzen Blondel nicht. Sie setzen Grenzen um ihn, was das Designproblem in eine Schleife uber n verwandelt. Das ist ein Programm, das ein Anfanger schreiben, Zeile um Zeile lesen und sich zu eigen machen kann. Zwei Stufen plus eine Stufentiefe: die alteste API in der Architektur.

Das Werkzeug: Python 3 und seine Standardbibliothek. Es gibt nichts zu pip-installieren und nur einen Import (math). Guido van Rossum begann die Sprache 1989 am CWI in Amsterdam, und die Python Software Foundation betreut sie heute. Python 3.15.0 kam Anfang Oktober heraus, am 9., mit Hugo van Kemenade als Release-Manager. Dieses Skript nutzt kein 3.15-Feature. Der Editor hat es auf Python 3.10.11 laufen lassen, und die Datei passt unverandert in Rhinos ScriptEditor, der CPython 3 ausfuhrt.

Die Regeln kommen von Menschen, nicht von der Sprache. Die wichtigste Quelle ist Beatrix Jeannottat, eine Architektin, die seit 2012 Hauser und Produkte in der BFU beraten hat. Ihre Fachdokumentation 2.007 Treppen (Bern, 2020) stellt die zwei Schweizer Spalten nebeneinander in Tabelle 1:

• Privattreppen (BFU-Empfehlungen): Stufentiefe a von 26–29 cm und Stufenhohe s von 17–19 cm, plus drei Formeln. Die Schrittformel ist 2s + a = 63 cm, die Komfortregel ist a − s ≈ 12 cm, und die Sicherheitsregel ist a + s = 46 cm.
• Offentlich zugangliche Treppen (SIA 500 Hindernisfreie Bauten): Stufentiefe ≥ 28 cm und Stufenhohe ≤ 17,5 cm. Fur die drei Formeln steht in der Spalte «Keine Angabe».

Die BAV-Checkliste fur Umlaufbahnen (Version 2.0, Juli 2026) zitiert dieselben SIA-500-Werte unter Ziff. 3.6.2. Unter Ziff. 3.6.1 vermerkt sie, dass ein Treppenlauf von 16 Stufen oder mehr ein Zwischenpodest braucht. BFUs Tabelle 4 setzt diese Schwelle auf 16–18 Stufen in Gebauden und gibt die Podestformel zur Bemessung des Podests an: ½a + n Schritte + ½a. Ehrlich gesagt: Dieser Text liest SIA 500 durch diese zwei Zusammenfassungen, nicht aus der Norm selbst. Das Skript beglaubigt nichts.

←HEUTE: Im Jahr 2026 wird die Stufenanzahl in einer ersten Sektion festgelegt, dann zwei Jahre lang verteidigt. →3012: In Zurich-3012 wird die Treppe noch nach dem menschlichen Schritt gezeichnet, weil der Schritt nie aktualisiert wurde. Angelpunkt: Eine Korperregel des 17. Jahrhunderts und eine 75-Zeilen-Schleife treffen sich in der einen Ziffer, die man nicht mehr andern kann.

Vorbereitung:

# Python 3.10 oder neuera; nur Standardbibliothek
python --version
mkdir stair-check
cd stair-check
# Programm unten als stair_check.py speichern, dann ausfuhren:
python stair_check.py
# Rhino 8: ScriptEditor eingeben, neues Python-3-Skript erstellen,
# dieselbe Datei einfugen und Ausfuhren drucken

Erste Schritte:

1. Speichern Sie das Programm als stair_check.py und starten Sie es mit den Beispielwerten H = 2900 und L = 5000. Die Konsole druckt eine Sanitats-Zeile und zwei Tabellen.
2. Lesen Sie zuerst die Sanitats-Zeile. Eine 17/29-cm-Treppe gibt 630, 120 und 460, also trifft sie alle drei Formeln genau. Suva nennt 17 : 29 «ideal», und Sophie Jung erinnert sich in Baunetzwoche #417, dass Neuferts Bauentwurfslehre 17 × 29 cm als die angenehmste Treppe nennt.
3. Anderm Sie H auf Ihre Buros Geschosshohe und L auf den Lauf, den Ihr Plan der Treppe tatsachlich gibt, dann starten Sie erneut. Die Zeilen, die uberleben, sind Ihre Optionen. Lesen Sie die Verdict-Spalte vor den Zahlen.

Der Code erklart:

# stair_check.py - einen geraden Treppenlauf bemessen und jedes Kandidat gegen die Schweizer Regeln testen
# Nur Standardbibliothek. Alle Langen in mm. Passt unverandert in Rhinos ScriptEditor (Python 3).
import math

H = 2900            # Geschosshohe, fertige Fussbodenoberkante zu fertige Fussbodenoberkante
L = 5000            # horizontaler Lauf, der fur die Treppe verfugbar ist (erste zur letzten Nasenlaufkante), mm
STRIDE = 630        # 2 s + a Ziel (BFU: 63 cm; Bereich 59-65 cm)

RULES = {           # Stufentiefe a min/max, Stufenhohe s min/max (mm), Podest ab N Stufen erforderlich
    "SIA 500 offentlich zugangbar": dict(a=(280, 9999), s=(0, 175),   landing=16),
    "BFU Privattreppe":     dict(a=(260, 290),  s=(170, 190), landing=16),
}

def three_rules(s, a):
    """Blondel-Schrittformel, Komfortregel, Sicherheitsregel (BFU Fachdokumentation 2.007)."""
    stride = 590 <= 2 * s + a <= 650
    comfort = abs((a - s) - 120) <= 20          # a - s ~ 12 cm
    safety = 450 <= a + s <= 470                # a + s = 46 cm
    return stride, comfort, safety

def candidates(H, L, rule):
    """Jede Stufenanzahl ausprobieren; Stufentiefe aus der Schrittformel, begrenzt durch den verfugbaren Lauf."""
    out = []
    for n in range(10, 25):                     # n Stufen -> n - 1 Stufentiefen in einem geraden Treppenlauf
        s = H / n
        a_rule = STRIDE - 2 * s                 # Stufentiefe, die die Schrittformel verlangt
        a = min(a_rule, L / (n - 1))            # aber nicht mehr als der Lauf zulasst
        run = a * (n - 1)
        ok_s = rule["s"][0] <= s <= rule["s"][1]
        ok_a = rule["a"][0] <= a <= rule["a"][1]
        out.append((n, s, a, run, ok_s, ok_a, n >= rule["landing"]))
    return out

def report(name, rule):
    print(f"
=== {name}: Stufentiefe {rule['a'][0]}-{rule['a'][1]} mm, Stufenhohe {rule['s'][0]}-{rule['s'][1]} mm,"
          f" Podest ab {rule['landing']} Stufen ===")
    print(f"{'n':>3}{'s mm':>8}{'a mm':>8}{'2s+a':>7}{'a-s':>6}{'a+s':>6}{'deg':>6}"
          f"{'Lauf m':>7}  Urteil")
    for n, s, a, run, ok_s, ok_a, landing in candidates(H, L, rule):
        if not (ok_s and ok_a):
            continue
        stride, comfort, safety = three_rules(s, a)
        ang = math.degrees(math.atan2(s, a))
        notes = []
        if not stride:  notes.append("Schritt")
        if not comfort: notes.append("Komfort")
        if not safety:  notes.append("Sicherheit")
        if landing:     notes.append("Treppenlauf + Podest teilen")
        verdict = "OK" if not notes else "prufen: " + ", ".join(notes)
        print(f"{n:>3}{s:8.1f}{a:8.1f}{2*s+a:7.0f}{a-s:6.0f}{a+s:6.0f}{ang:6.1f}"
              f"{run/1000:7.2f}  {verdict}")

def split_flight(n, s, a):
    """Zwei Treppenl aufe mit einem Zwischenpodest: Podestiefe aus der BFU Podestformel a + k*Schritt, k>=2."""
    n1 = math.ceil(n / 2); n2 = n - n1
    landing = a + 2 * STRIDE
    run = (n1 - 1) * a + landing + (n2 - 1) * a
    print(f"
{n} Stufen als {n1} + {n2} teilen: Stufenhohe {s:.1f} mm, Stufentiefe {a:.0f} mm,"
          f" Podest >= {landing:.0f} mm (a + 2 Schritte),")
    print(f"  Gesamtlauf {run/1000:.2f} m in einer geraden Linie, oder {(max(n1, n2) - 1) * a / 1000:.2f} m"
          f" pro Treppenlauf, wenn er sich um 180 Grad dreht.")

def site_check(s, finish_mm):
    """Eine Schicht, die nur auf dem oberen Geschoss verlegt wird, verschiebt die LETZTE Stufenhohe. BFU Sturzgrenze: 6 mm."""
    last = s + finish_mm
    print(f"
Baustellenkontrolle: {finish_mm} mm zusatzliche Schicht nur auf dem oberen Geschoss -> letzte Stufenhohe"
          f" {last:.1f} mm gegenuber {s:.1f} mm, Unterschied {finish_mm} mm"
          f" -> {'Sturzfalle (> 6 mm)' if finish_mm > 6 else 'im 6-mm-Bereich'}")

print(f"Geschosshohe {H} mm, Lauf verfugbar {L} mm, Schritt-Ziel {STRIDE} mm")
print(f"Kontrolle: 17/29 cm -> 2s+a = {2*170+290} mm, a-s = {290-170} mm, a+s = {290+170} mm")
for name, rule in RULES.items():
    report(name, rule)
split_flight(17, H / 17, STRIDE - 2 * H / 17)
site_check(H / 17, 20)

Das Starten von python stair_check.py druckt genau das:

Geschosshohe 2900 mm, Lauf verfugbar 5000 mm, Schritthohe 630 mm
Kontrolle: 17/29 cm -> 2s+a = 630 mm, a-s = 120 mm, a+s = 460 mm

=== SIA 500 offentlich zugangbar: Stufentiefe 280-9999 mm, Stufenhohe 0-175 mm, Podest ab 16 Stufen ===
  n    s mm    a mm   2s+a   a-s   a+s   deg  Lauf m  Urteil
 17   170,6   288,8    630   118   459  30,6   4,62  prufen: Treppenlauf + Podest teilen
 18   161,1   294,1    616   133   455  28,7   5,00  prufen: Treppenlauf + Podest teilen

=== BFU Privattreppe: Stufentiefe 260-290 mm, Stufenhohe 170-190 mm, Podest ab 16 Stufen ===
  n    s mm    a mm   2s+a   a-s   a+s   deg  Lauf m  Urteil
 16   181,2   267,5    630    86   449  34,1   4,01  prufen: Komfort, Sicherheit, Treppenlauf + Podest teilen
 17   170,6   288,8    630   118   459  30,6   4,62  prufen: Treppenlauf + Podest teilen

Treppenlauf 17 Stufen als 9 + 8 teilen: Stufenhohe 170,6 mm, Stufentiefe 289 mm, Podest >= 1549 mm (a + 2 Schritte),
  Gesamtlauf 5,88 m in einer geraden Linie, oder 2,31 m pro Treppenlauf, wenn er sich um 180 Grad dreht.

Baustellenkontrolle: 20 mm zusatzliche Schicht auf dem oberen Geschoss nur -> letzte Stufenhohe 190,6 mm gegenuber 170,6 mm, Unterschied 20 mm -> Sturzfalle (> 6 mm)

Zeilen 1–12 — Eingaben und Regeln als Daten: Alles in Millimetern, damit man nie eine ×1000 vergisst. H und L sind Beispieleingaben, nichts mehr. RULES ist ein Worterbuch, eine Nachschlagetabelle, die einen Namen an einen Wert knupft. Jede Grenze ist ein Tupel, ein festes Paar (min, max), und 9999 steht stellvertretend fur «keine maximale Stufentiefe». Regeln als Daten speichern statt als if-Aussagen bedeutet, dass Ihr Buro eine dritte Gruppe hinzufugen kann, zum Beispiel die SN-640-075-Spalte fur offentliche Freitreppenlaufe, ohne die Logik zu verandern.

Zeilen 14–19 — Blondel in drei Satzen: Eine Funktion ist ein benannter Block Code, den man immer wieder aufrufen kann. Diese gibt drei Wahrheitswerte zuruck, einfache Wahr/Falsch-Antworten. Das Fenster von 590–650 mm ist der Erwachsenenbereich, den BFU druckt. Das ±20-mm-Komfortband und das 450–470-mm-Sicherheitsfenster sind die Toleranzen des Editors, gelesen gegen BFUs «≈ 12 cm» und 45–47 cm. Sie sind kein Normtext, also setzen Sie Ihre eigenen.

Zeilen 21–32 — die Schleife, die der ganze Algorithmus ist: Eine Schleife bedeutet «dies einmal fur jeden Wert tun». for n in range(10, 25) probiert jede Stufenanzahl von 10 bis 24. s = H / n ist die Stufenhohe, STRIDE - 2 * s ist Blondel umgestellt, und min(a_rule, L / (n - 1)) halt diese Stufentiefe, es sei denn, der Plan hat keinen Platz. Dieses eine min erklart Zeile 18: die Regel verlangt 307,8 mm, aber 5.000 / 17 = 294,1 mm ist alles, was der Lauf zulasst, also sinkt 2s + a auf 616, immer noch im 59–65-cm-Fenster. Der Anfangerfehler sitzt im Kommentar auf Zeile 24. In einem geraden Treppenlauf geben n Stufen n − 1 Stufentiefen, weil das obere Geschoss die letzte «Stufentiefe» ist. Teile durch n und der Lauf kommt um eine Stufentiefe zu kurz, und niemand merkt es, bis die Bauleitung misst.

Zeilen 34–51 — der Bericht: Das f vor einer Zeichenkette macht sie zu einem f-String: {s:8.1f} setzt eine Zahl, acht Zeichen breit mit einer Dezimalstelle, ein, was die Spalten ausfuhrt. continue uberspringt Kandidaten ausserhalb der Grenzen. math.atan2(s, a) gibt die Neigung in Radiant, und math.degrees konvertiert. Jetzt die Wendung. Unter SIA 500 gibt n = 16 181,2 mm, uber 175, also uberleben nur 17 und 18, und beide uberschreiten die 16-Stufen-Podest-Schwelle. Unter BFU besteht 16 die Grenzen, schlaegt aber Komfort (86) und Sicherheit (449) fehl. Bei 2,90 m gibt es keinen sauberen geraden Treppenlauf in beiden Gruppen. Die Treppe hat Meinungen, und sie sind 17. Jahrhundert.

Zeilen 53–75 — Podest, Baustelle, Laufbestellung: math.ceil rundet auf, also 17 Stufen als 9 + 8 teilen. Die Podestformel mit zwei Schritten gibt 288,8 + 1.260 = 1.549 mm Podestiefe. Gerade braucht diese Treppe 5,88 m, mehr als die 5,00 m verfugbar, was Sie zu einem Hundebein bei 2,31 m pro Treppenlauf drangt. Dann site_check: Eine 20-mm-Schicht, die nur auf dem oberen Geschoss verlegt wird, macht die letzte Stufenhohe 190,6 mm gegen 170,6 mm uberall sonst.

Warum die letzte Zeile wichtig ist

Die BFU massnahm 2023 529 offentliche Treppen, 242 innen und 287 aussen, uber Basel, Bern, Lausanne und Zurich. Nach ihrer Pressemitteilung vom 12. Januar 2024 unterschieden sich die Stufen auf mehr als zwei Drittel davon in der Hohe um mindestens 6 mm, und die BFU stellt fest, dass 6 mm bereits ausreichen, um Sturze zu verursachen. Dieselbe Pressemitteilung zahlt mehr als 90 Todesfalle und mehr als 50.000 Verletzungen durch Treppenstuurze in der Schweiz jeden Jahr. Diese Daten sind nun fast drei Jahre alt, und sie existieren, weil Menschen diese Treppen mit Masseinrichtungen gingen. Sie sind der Grund, warum Zeile 75 existiert.

Der Kompromiss ist klar: Das Skript pruft die Treppe, die Sie gezeichnet haben, nicht die Schicht, die jemand nach jedem durchgepassten Zeichensatz verlegt.

Atelier: In einem zwolf-Personen-Zurich-Studio wird die Stufenanzahl in der ersten Vorprojekt-Sektion festgelegt, wahrend die Geschossaufbauten immer weiter verschieben, bis zur Ausfuhrungsplanung, und die Treppe wird erwartet, den Unterschied zu absorbieren. Montagmove: stair_check.py in Ihren Burotemplateordner mit Ihren Standard-Geschosshohen gefullte Datei legen, und keinen Treppenraum zeichnen, bis beide Geschosse’ fertige Aufbauten durch site_check gegangen sind.

Hack: Finde heraus, wie dunn ein einseitiger Ausgleich sein muss, bevor das Skript dir nicht mehr warnt. Andere 20 mm auf 5 mm und sage die letzte Zeile voraus, bevor du Ausfuhren druckst.

# ersetze die letzte Zeile von stair_check.py mit:
site_check(H / 17, 5)        # 5 mm Ausgleich statt 20 mm
# erwartete letzte Zeile endet mit:
# letzte Stufenhohe 175,6 mm gegenuber 170,6 mm, Unterschied 5 mm -> im 6-mm-Bereich

Schaue dann auf finish_mm > 6. BFU sagt, 6 mm verursacht bereits Sturze, dennoch druckt ein 6-mm-Ausgleich immer noch «im 6-mm-Bereich». Ob man es auf >= 6 verstarken will, ist Ihres Buros Entscheidung. Machen Sie es im Code, wo die nachste Person es sehen kann.

PAZ Academy lehrt diese Skript-zuerst-Gewohnheit in seinen Rhino-8- und Grasshopper-2-Kursen. Dieselbe Datei wird spater zu einer Script-Komponente, die H gerade von Ihrem Schnitt liest, aber sie beginnt hier, als reines Python, das Sie bis zum Ende lesen konnen.

Lern-Material:

• BFU Fachdokumentation 2.007 Treppen (Beatrix Jeannottat, 2020): Tabelle 1 und 4 sind die Regelgruppen, die dieses Skript codiert.
• BAV-Checkliste, BehiG-Anforderungen (Juli 2026): SIA 500 Ziff. 3.6 wie zitiert.
• BFU-Erhebung: Viele offentliche Treppen bergen Stolperfallen: die 529 Treppen und die 6-mm-Feststellung.
• Baunetzwissen: Steigungsverhältnis: Blondels drei Formeln erklart.
• PAZ-Notiz: dieselbe Einfach-Datei-Gewohnheit, angewendet auf Turen — IfcOpenShell 0.9.0: eine Python-Turenliste in 30 Zeilen.

Offne die Sektion auf deinem Schreibtisch, lese H ab, und starte die Kontrolle, bevor jemand die erste Stufentiefe zeichnet.