Kapitel 15 von 15nullos.de

Chronik

Wie aus einer Kindheitsidee ein Betriebssystem wird – Commit für Commit.

Meilensteine

früherMax hat als kleiner Junge die Idee: ein eigenes Betriebssystem.
28.10.2026 19:30Startschuss.
19:41Projektordner und Git-Repo angelegt.
19:54Erster Boot: nb startet in QEMU, nk zeigt einen Prompt – eigene Schrift, Tastatur, serielle Konsole.
20:03Katalog komplett: 409 Werkzeuge mit Kurznamen.
20:26Der eigene C-Compiler übersetzt sich selbst.
20:45Kernel nur mit eigenem Compiler, Assembler und Linker gebaut – bootet.
21:09Erste Download-Abbilder: USB/Platte (.img) und Live-CD (.iso), starten in QEMU.
21:10Der Editor e ist da.
21:19Kernel kann Prozesse: alle 44 Systemaufrufe, ELF-Lader, Rohre, Signale, RAM-Dateisystem.
21:20Die eigene libc steht.
21:22Der Compiler kann RISC-V 64.
21:23ESP32-C5 wird das erste Kleingerät.
21:25Kernel liest SATA-Platten und FAT.
22:29Shell und Werkzeuge laufen auf nullos selbst – der Kernel startet s beim Hochfahren.
23:10Ganz nullos – Kernel, libc, 280 Werkzeuge – nur mit dem eigenen Compiler gebaut, läuft.
23:16cc übersetzt sich auf nullos selbst.
29.10. 00:05Eigener Python-Interpreter py: Testsammlung grün (auf dem Mac).
00:42Deutsche Tastatur mit Umlauten.
00:51py übersetzt alle 635 Dateien der Python-3.15-Standardbibliothek fehlerfrei.
00:53Python läuft auf nullos.
01:07Sockets im Kernel: IPv4 und IPv6, erst mal innerhalb des Rechners.
01:29nullos ist im Netz: virtio-net und e1000, eigener TCP/IP-Stapel mit IPv6 und IPv4.
01:32Zwei nullos reden über TCP miteinander.
–Erster Boot auf einem echten PC vom USB-Stick kommt noch
–nullos.de geht online kommt noch

Jeder Schritt

Automatisch aus dem Git-Log (ohne die „belegt“-Commits der Fabriken).

28.10.2026

  1. Projektstart nullos: Leitlinien, Namensregeln, Architektur für alle Geräte, Sessions-Plan, Chronik
  2. ABI Fassung 0, Hilfsbibliothek lib/n, Vorlage-Werkzeug c (kopieren) mit Test, Makefile host/test
  3. Katalog Kernsatz (45 Werkzeuge mit Kurznamen), Session-Regeln für parallele Worktrees
  4. Recherche: Betriebssysteme, Themenvergleich, 123 Best-of-all-Features, 23 eigene Ideen (Merkmale teils aus dem Gedächtnis, markiert)
  5. Recherche: 763 Basis-Werkzeuge aus Linux, macOS, Windows, Android, BSD (eine Zeile je Funktion)
  6. Erster Boot: UEFI-Bootloader nb, Kernel nk mit Prompt, eigene Linienschrift, PS/2-Tastatur, serielle Konsole, Boot-Test make check; Recherche Bausteine/Lizenzen/neue Technik
  7. Werkzeug d (delete): löschen mit -r -f -v -n, schützt /, . und .., Test mit Randfällen
  8. Werkzeug m (move): umbenennen/verschieben, Kopieren+Löschen über Laufwerke, -f -v -n, Test mit vielen Randfällen
  9. Werkzeug f (find): Glob-Suche mit -t -s -a -x -0, Test, Spec, README
  10. Werkzeug md: Aufbau nach Vorlage c, mit Spec, Test und README
  11. Werkzeug rd: Aufbau nach Vorlage c, mit Spec, Test und README
  12. Werkzeug rn: Aufbau nach Vorlage c, mit Spec, Test und README
  13. Werkzeug ln: Aufbau nach Vorlage c, mit Spec, Test und README
  14. Werkzeug t: Aufbau nach Vorlage c, mit Spec, Test und README
  15. Werkzeug st: Aufbau nach Vorlage c, mit Spec, Test und README
  16. Werkzeug l (list): sortiert, Spalten am Terminal, -a -l -r -t -s -d, Test
  17. Werkzeug g (grep): eigene Regex-Maschine POSIX ERE, -i -v -n -c -l -r -w -F -q, Test gegen grep -E
  18. Werkzeug sh (show): cat/type/tac mit -n und -r, Test
  19. Werkzeug hd (head): erste N Zeilen oder Bytes, Test
  20. Werkzeug tl (tail): letzte N Zeilen oder Bytes, -f, Test
  21. Werkzeug cn (count): Zeilen, Wörter, Bytes, Zeichen, Test
  22. Werkzeug pr (print): echo, printf, yes, seq in einem, Test
  23. Katalog vollständig: 409 Werkzeuge mit Kurznamen (P0 27, P1 66, P2 92, P3 224), 59 Shell-Builtins, katalog.tsv für Skripte
  24. Werkzeug te (tee): Eingabe an Ausgabe und Dateien, -a, -i, Test
  25. Werkzeug u (unique): doppelte Zeilen entfernen/zählen, -c -d -u -i -a, Test
  26. Werkzeug xa (xargs): Argumente aus Eingabe, -n -I -0 -p -t, Test
  27. Werkzeug hx (hex): Hex-Ansicht, -s/-n/-o/-c, -r zurück in Bytes, Test mit Rundreise
  28. Werkzeug tr (translate): Zeichen ersetzen/löschen/zusammenfassen, Tabs wandeln, Zeilen umbrechen, Test
  29. Werkzeug en (encode): base64, base32, base16, url, uu in einem, streamt in 4-KB-Blöcken, Test
  30. Werkzeug di (diff): Myers-Vergleich, unified, -r -q -b -c, mit patch getestet
  31. di: Aufräumen
  32. Werkzeug so (sort): -r -n -h -k -t -u -f -c, externes Mischen über Zwischendateien, Test
  33. Werkzeug ct (cut): Felder, Zeichen, kleben, verbinden, Tabelle, Test
  34. Bootloader: Bildschirmgröße dezimal, optionale Pause für Vorführungen (NBFLAGS=-DNB_PAUSE=ms), Bildschirmfoto docs/bootloader.png
  35. Werkzeug hs (checksum): SHA-256, SHA-512, SHA-1, MD5, SHA3-256, BLAKE2b, BLAKE3, CRC-32, Prüfen mit -c, Test
  36. Werkzeug ca (calculate): Rechnen mit Langzahlen, Dezimalstellen, Variablen, Funktionen, expr-Modus, Test gegen bc
  37. Werkzeug sr (substitute): ersetzen, sed-Skripte mit -e, -i, eigene Regex-Maschine mit Gruppen, Test
  38. Werkzeug mk (make): POSIX-make plus GNU-Teile des eigenen Makefiles, -j parallel, -C, -n, include; mk -n host = make -n host; Test
  39. cc: erster Stand des eigenen C-Compilers (Lexer, Präprozessor, Parser, x86_64-Codeerzeugung, eigene Header)
  40. cc: Testsuite (13 Dateien), Fehler in Präprozessor, Konstanten und va_arg behoben
  41. Werkzeug zp (compress): eigenes DEFLATE (packen + entpacken), gzip, zlib, LZ4-Rahmen, zstd entpacken, Test
  42. cc: Assembler-Namen (__asm__), sys/stat.h, dirent.h für macOS; Zeigerschritt in Komponenten behoben; alle 30 Werkzeuge aus cmd/ laufen mit cc
  43. cc: README, ABI-Test gegen clang (beide Richtungen), ohne atexit (nur ABI-Funktionen)
  44. Shell s: Bash-Syntax, Zeileneditor mit Verlauf, Tab-Vervollständigung aus den specs, Test gegen bash 5
  45. Werkzeug aw (awk): eigener Interpreter mit eigener Regex-Maschine, POSIX-Umfang, Test gegen macOS-awk
  46. s: ohne fork (N_NOFORK) mit Zwischendateien und gesicherter Subshell, schneller Zeileneditor, Ausgabe ohne Zeilenende bleibt stehen
  47. cc: eigener x86_64-Assembler (as.c) mit ELF- und Mach-O-Ausgabe (obj.c); Standard statt clang
  48. s: 83 weitere Fälle gegen bash (Quotes in ${}, IFS, read am Ende, trap ERR, Felder); Zeitgrenze je Fall im Test
  49. cc: eigener ELF-Linker (ld.c), Inline-Assembler, .S-Dateien; nullos-Kernel nur mit eigener Werkzeugkette gebaut bootet in QEMU
  50. s: declare -f/type geben Funktionen wie bash aus (unparse.c), FUNCNAME als Aufrufkette, ohne ] ist kein Muster (schneller)
  51. s: Aliase aus specs in der interaktiven Shell, compgen/enable, BASH_VERSION/UID/OSTYPE (brew läuft), Fehler bei exec in Funktion als Subshell behoben
  52. lib/n: n_spawn/n_wait für parallele Aufträge (Wunsch von xa -p)
  53. s: Prozessersetzung <( ) >( ), Verlauf ersetzen (!! !$ !text), time, $_, pushd/popd/dirs, umask, complete/bind ohne Wirkung
  54. cc: README auf Stand Assembler/Linker/Kernel
  55. cc: zweiter Codeerzeuger ARM64 (Apple-AAPCS64), läuft nativ: 15/15 Tests, 33/33 Werkzeuge, Selbstübersetzung stabil
  56. cc: Header setjmp.h, math.h, locale.h, mehr stdio/float; Lua 5.4.7 übersetzt vollständig (34 Dateien), eigener Assembler dort gleich wie clang
  57. Werkzeug-Fabriken: Regeln zum Belegen, Plattformdateien, Abgleich
  58. s: source sucht lesbare Dateien im PATH (git filter-branch läuft), set -x zeigt Zuweisungen richtig, Funktion zweimal im selben Baum
  59. h: Hilfe-Werkzeug (Liste nach Katalog-Gruppen, h NAME, h -s Suche mit alten Namen, NHELP, gen.sh)
  60. Systemaufrufe: Vertrag docs/syscalls.md + include/nullos/sys.h (Nummern, Fehler, Strukturen) für die libc
  61. Belegt: bl sp mo part fs ck (fabrik-hardware)
  62. arc: Beleg an nullos-arc übergeben (dort läuft die Arbeit schon)
  63. Werkzeug cm (C): Rechte ändern, oktal und symbolisch, -r
  64. Werkzeug wh (C): Befehl im PATH finden
  65. Werkzeug mn (C): Pipes und Gerätedateien anlegen
  66. Werkzeug str (strings): druckbare Zeichenfolgen, -n -t -f
  67. Werkzeug str (strings): Test und README fertig
  68. s: Strg-C bricht read und Schleifen ab (siginterrupt), Fehlermeldungen in Skripten mit Skriptname wie bash; configure-Probe in README
  69. Werkzeug asm (assemble): x86_64-Assembler als Hülle um cc/as.c
  70. Werkzeug dd (blockcopy): if/of/bs/count/skip/seek/conv
  71. Werkzeug ev (env): fertig auf dem Mac
  72. Werkzeug sl (sleep): fertig auf dem Mac
  73. Werkzeug cs (clear): fertig auf dem Mac
  74. Werkzeuge sy, sz, tmp (C): sync, Platzverbrauch, Temporärdateien
  75. Belegt: p, k, tp (fabrik-system)
  76. Werkzeug id (identity): Benutzer/Gruppen anzeigen, -u -g -G -n, Test ok
  77. Werkzeug who (loggedin): Anmeldeliste zeigen, Test ok
  78. Werkzeuge ins, tru, lk (C): install, truncate, Dateisperre
  79. Werkzeug lib (library): ar-Archive anlegen, ändern, lesen
  80. s: erweiterte Muster (extglob) und (globstar) wie bash
  81. Werkzeug ld (linker): Hülle um cc/ld.c, dazu Archive (.a, -l, -L)
  82. Werkzeug to (timeout): fertig auf dem Mac
  83. Werkzeug tm (timeit): fertig auf dem Mac
  84. Werkzeug tty (ttyname): fertig auf dem Mac
  85. Werkzeug sty (termset): fertig auf dem Mac
  86. Werkzeuge rv (reverse) und nl (numberlines)
  87. Werkzeug pt (C): patch für diff -u mit Verschiebung, -R, -n, neue/gelöschte Dateien
  88. Werkzeug rst (reset): fertig auf dem Mac
  89. Werkzeug p (process): Prozesse anzeigen, suchen, Baum, sortieren
  90. Werkzeug pi (ping): ICMP-Echo IPv4/IPv6 ohne Sonderrechte, Netz-Schnittstelle net.h (net.c, net_host.c, net_nullos.c)
  91. Werkzeug part (partition): GPT und MBR auf Abbildern anlegen, ändern, reparieren
  92. pg: Pager (blättern, suchen, folgen, -n -S), Terminal-Modul term.c, Test mit Tastendatei
  93. Abgleich: tools/abgleich.py prüft Katalog gegen cmd/ (frischer Bau, alle Tests, cc-Tests, Boot-Test), Status-Spalte in katalog.md/.tsv, neuer Stand in docs/stand.md
  94. Werkzeug spl (split): Zeilen, Bytes, Anzahl, Textmarke
  95. Werkzeug rst (reset): Plattformdatei gekürzt, Test korrigiert, baut ohne Warnung
  96. Werkzeug usr (user): Benutzer anlegen/ändern/sperren/löschen, Test ok
  97. Werkzeuge fa, xat (C): Dateiattribute und erweiterte Attribute (Mac; nullos Platzhalter)
  98. Werkzeug k (kill): beenden nach Nummer oder Name, Signale, -w warten, Vorschlag bei Tippfehlern
  99. Werkzeug fmt (reflow): Absätze umbrechen
  100. cc: x86_64-Code schneller und kleiner (Variablen direkt im Speicher, einfache rechte Operanden, Vergleiche als Sprung, einfache Argumente direkt ins Register)
  101. Werkzeug obj (objinfo): Kopf, Abschnitte, Symbole, Größen, Verschiebungen von ELF und Archiven
  102. Belegt: mem sys up log ni nh dt off (fabrik-system)
  103. Doku: doku/ mit 9 Kapiteln (HTML, eine CSS, hell/dunkel), Generator tools/doku/gen.c (Werkzeugkarten aus spec+README, Chronik aus Git-Log), tools/doku/build.sh
  104. Werkzeug opt (getopt): getopt mit Langoptionen, Quoting, Permutation
  105. Werkzeug sf (shuffle)
  106. s: BASH_SOURCE, declare -n, select, printf %()T, nocasematch, BASHPID, HISTCONTROL
  107. Doku: Status aus Katalog-Spalte und docs/stand.md, alte Namen aus dem Katalog in den Karten (Suche findet robocopy → c)
  108. Werkzeug psw (password): Passwort setzen/prüfen, PBKDF2-SHA256, Test ok; Benutzerbaustein: Salt ab 4 Byte
  109. Werkzeug eol (lineends)
  110. Werkzeug dns (dnslookup): eigener DNS-Client UDP/TCP, A AAAA MX TXT NS CNAME SOA PTR SRV CAA, rückwärts
  111. Werkzeuge acl, loc (C): Zugriffslisten (Mac), Dateiindex
  112. psw: README Status fertig
  113. Werkzeuge of, op (C): offene Dateien (Mac), Öffnen mit passendem Programm
  114. Werkzeug su (superuser): als anderer Benutzer, Passwortprüfung, Test ok
  115. Werkzeug ic (charset): iconv mit UTF-8/16/32 und 8-Bit-Tabellen
  116. Werkzeug ocp (objcopy): strip, -g, -R, -j, Rohdaten; elf.c in Teile gegliedert
  117. Werkzeug arc (archive): tar (ustar, pax, GNU-Langnamen), cpio newc, zip (DEFLATE, zip64) mit gzip/zlib/LZ4, zstd auspacken, sicheres Auspacken, Test mit tar/cpio/zip/unzip in beide Richtungen
  118. Werkzeug wa (watch): Befehl wiederholen mit Kopfzeile, -c/-e/-t/-p
  119. s: kill/wait nehmen nur Nummern (kill text traf sonst die eigene Prozessgruppe), Here-Dokument am Eingabeende stürzte ab; Zufallstests ohne Absturz
  120. Werkzeug lgn (login): Anmeldung mit utmp/wtmp/btmp, nologin, Test ok; su liest Passwort Byte für Byte
  121. Release-Abbilder: nullos-<v>-x86_64.img (GPT+ESP) und .iso (UEFI-Live-CD, hybrid), SHA256SUMS, Boot-Test in QEMU, Installer inst.sh (nur Abbilddateien) mit Entwurf
  122. Werkzeug gc (getconf): fertig auf dem Mac
  123. Werkzeug lc (locale): fertig auf dem Mac
  124. Kernel: obere Hälfte mit Seitentabellen aus nb, GDT/IDT/TSS, Ausnahmen mit lesbarer Panik, APIC/IOAPIC, Zeitgeber am HPET geeicht, Tastatur und seriell per IRQ, Seitenverwalter, Heap, Planer, Terminal
  125. Werkzeug gty (getty): Begrüßung + Anmeldung in Schleife, Test ok
  126. cc: ARM64-Code schneller (ldur/stur für lokale Variablen, Sofortwerte, Vergleiche als Sprung, einfache Argumente direkt)
  127. Werkzeug lw (logwrite): fertig auf dem Mac
  128. Werkzeug ldd (libdeps): Lader und Bibliotheken eines ELF-Programms, ohne es auszuführen
  129. Werkzeuge hl, trs, xc, sn (C): Duplikate verlinken, Papierkorb, Tauschen, 8.3-Namen
  130. s: ohne fork über n_spawn/n_wait aus lib/n.h (eigener Nachbau entfällt)
  131. Werkzeug la (lastlogins): letzte Anmeldungen aus wtmp/btmp, Test ok
  132. Werkzeug dl (download): eigenes HTTP/1.1 mit chunked, Umleitungen, Fortsetzen, POST, Proxy; HTTPS fehlt noch
  133. Werkzeug tp (top): Task-Manager mit CPU je Kern (E/P), Speicher wie Aktivitätsanzeige, sortieren, filtern, beenden, Stapelmodus
  134. Doku: 15 Kapitel – neu Herunterladen, Installieren (je Medium, Warnung), Werkzeug-Bibliothek (ganzer Katalog, generiert), Treiber, Selbst bauen, Werkzeugkette (Versionen nachgeschaut); stabile Dateinamen; gen baut auch mit eigenem cc
  135. Werkzeuge cch (C), se (ausgelassen mit Grund)
  136. e: Texteditor (edit) – wie nano, mit vi-Modus, Farben für C/Shell/Python/Markdown, UTF-8, Piece Table für Dateien größer als der Speicher
  137. Werkzeug grp (group): Gruppen verwalten, Test ok
  138. Werkzeug fs (filesystem): FAT12/16/32 anlegen, füllen, auflisten, auspacken; bootfähiges USB-Abbild (usb.sh) startet in QEMU
  139. Werkzeug cal (calendar): Monat, Jahr, -3, Wochen, Sonntag zuerst
  140. Werkzeug ldc (ldconfig): SONAME-Verweise und Zwischenspeicher für ldd
  141. Werkzeug nss (nameservice): Datenbanken abfragen, Test ok
  142. Werkzeug mem (memory): Speicher wie Aktivitätsanzeige (Apps, fest, komprimiert, Cache), Swap, -q Prozent, -s wiederholen
  143. s: Test auch ohne bash (S_OHNE_BASH, cases.exp ohne Pfade), Status mit Größe und Laufzeit
  144. Werkzeug sys (system): Übersicht OS/Rechner/CPU/Speicher/Laufzeit, uname-Optionen
  145. s: weitere Fälle mit typischen Skript-Redewendungen (read -d '', read -ra, ${a@]/#/x}, local IFS, trap-Funktionen)
  146. Werkzeug up (uptime): Laufzeit, Benutzer, Last; -s Start, -p Worte, -q Sekunden
  147. Werkzeug at (atjob): Aufträge vormerken, listen, löschen, ausführen
  148. Werkzeug efs (C): Datei mit Passwort verschlüsseln (PBKDF2, ChaCha20, HMAC-SHA256)
  149. cc: weitere POSIX-Header (sys/select.h, sys/file.h, pwd.h, grp.h, termios-Konstanten, chflags), Option -idirafter; 76/90 Werkzeuge
  150. Werkzeug nc (netcat): TCP/UDP Client und Server, -k, -z Portprüfung, Halbschluss, IPv6
  151. Werkzeuge mf, sd (C): Prüfliste für Ordner, Laufwerksbuchstaben-Tabelle
  152. Werkzeug ssl (crypto): Hashes, HMAC, PBKDF2, AES-CTR, enc, Base64, rand – gegen amtliche Vektoren, Test ok
  153. Werkzeug dt (date): deutsches Format, -d versteht ISO/TT.MM.JJJJ/@SEK/relativ/gestern, -i ISO, -e, -r, -s stellen
  154. Werkzeug ck (check): FAT12/16/32 prüfen und reparieren (Ketten, verlorene Cluster, lange Namen, FAT-Kopien, FSInfo)
  155. Werkzeug cr (cron): Zeitplan-Dienst mit Cron-Tabelle, Prüfen, nächste Zeit, Einzellauf
  156. fabrik-dateien: Abschlussbericht (fertig / teilweise / ausgelassen)
  157. Werkzeug m4 (macro): Makroprozessor, Test gleich mit GNU m4
  158. Werkzeug ip (interface): Schnittstellen anzeigen mit Adressen und Zählern, up/down/add/del; net_host: verborgene MAC erkennen
  159. Werkzeug ni (nice): starten mit Priorität, -p ändern, -s zeigen, -i I/O drosseln, Stufennamen
  160. m4: README genauer zum Vergleich mit GNU m4
  161. Werkzeug tz (timezone): Zeitzone zeigen, wählen, auflisten, Uhrzeit in Zone
  162. Werkzeug rtc (hwclock): Hardware-Uhr anzeigen (Mac: Systemzeit), Schreiben wartet auf Systemaufrufe
  163. Werkzeug nh (nohup): vom Terminal lösen, -b Hintergrund mit PID, -o Ausgabedatei
  164. Werkzeug sp (space): freier Platz für Einhängepunkte (macOS statfs) und FAT-Abbilder
  165. Werkzeug nt (ntp): SNTP-Abgleich, Abweichung und Laufzeit, Test mit eigenem Zeitserver
  166. Werkzeug pk (package): .npk installieren/entfernen/prüfen/packen, Paketquelle mit Abhängigkeiten, Test ok
  167. Werkzeug mo (mount): Einhängepunkte anzeigen (macOS), Ein-/Aushängen wartet auf den Kernel
  168. Werkzeug ti (terminfo): Terminal-Fähigkeiten als feste ANSI-Tabelle (tput-Ersatz)
  169. Werkzeug rt (route): Routentabelle, get (längste passende Route), add/del; net_host: KAME-Bereich bei Multicast, Nachbar-Einträge ausgelassen
  170. cc: ARM64-ELF mit va_list nach AAPCS64; Prüfstand rt/ (kleine libc + Startcode für QEMU virt): 15/15 Tests als ARM64-ELF in QEMU
  171. Werkzeug log: Systemprotokoll einheitlich (Zeit, Stufe, Prozess), -e -k -p -g -s -n -f, auch für Dateien
  172. Belegt: ini hn sct sv cpu (fabrik-system)
  173. Werkzeug sk (sockets): TCP/UDP-Sockets mit Programm, Filter nach Port/Programm, -l -s
  174. Werkzeug bl (blocks): Datenträger des Mac als Baum, Abbilder mit Partitionen und Dateisystem-Erkennung
  175. Werkzeug cb (clipboard): Zwischenablage als Datei: kopieren, anhängen, einfügen, leeren
  176. Belegt: hw lbl img rsz io sen (fabrik-hardware)
  177. Werkzeug off (poweroff): ausschalten/neu starten mit Nachfrage, -t Countdown, -n Probelauf
  178. Kernel: Prozesse, Systemaufrufe (alle 44 aus docs/syscalls.md), ELF-Lader (fest + PIE), fork/spawn/exec/wait, Rohre, Signale, VFS + RAM-Dateisystem aus init.img, /dev, FPU je Thread; utest 56/56, kein Speicherleck
  179. Werkzeug mx (multiplex): Sitzungen im Hintergrund: anhängen, lösen, senden, Rückblick
  180. Werkzeug dh (dhcp): eigener DHCP-Client DISCOVER/OFFER/REQUEST/ACK, Wiederholung, NAK, Setzen von Adresse/Route/DNS
  181. Werkzeuge rsv asc stv prv pol shr gk sip ftr (fabrik-rest): Tabellenwerkzeuge, Tests ok; ub_edit mit langen Schlüsseln
  182. Werkzeug trm (terminal): Terminal-Nachbildung als Text (Pseudo-Terminal, Cursor, Scrollen, UTF-8)
  183. Werkzeug hw (hardware): Übersicht, PCI- und USB-Geräte (macOS: sysctl, ioreg, system_profiler)
  184. Werkzeuge vfy lh lic (fabrik-rest): Tests ok
  185. Werkzeuge ini (init) und sv (service): Dienstliste mit einmal/start/immer/ende, Neustart mit Pause, Herunterfahren, tini-Art; sv steuert über Zustandsdateien + SIGCHLD
  186. cc: dritter Codeerzeuger RISC-V 64 (RV64GC, LP64D): 15/15 Tests in QEMU, ABI-Test gegen clang
  187. Werkzeug lbl (label): Datenträgername zeigen und bei FAT setzen
  188. Werkzeug fct (factor): Primfaktoren bis 2^64 (Miller-Rabin, Pollard-Rho), Primzahlliste
  189. Werkzeug hn (hostname): zeigen, -s kurz, -d Domain, setzen mit Prüfung
  190. Werkzeuge dcl bom (fabrik-rest): Tests ok
  191. Werkzeug yac (yacc): LALR(1)-Parsergenerator mit eigenem Gerüst, Ergebnisse gleich bison
  192. ESP32-C5 als erstes Kleingerät: Plan in Stufen, Ziel SSH, offene WLAN-Entscheidung
  193. Werkzeug nw (numwords): Zahlen in Worten, deutsch und englisch
  194. Werkzeuge aud kr (fabrik-rest): Prüfprotokoll mit Kette, Schlüsselbund, Tests ok
  195. Werkzeug img (image): Abbilder anlegen (dünn), untersuchen, Partitionen heraus- und hineinkopieren
  196. Werkzeug mrs (morse): Morsezeichen hin und zurück, Caesar-Verschiebung
  197. Werkzeug sct (sysctl): alle/Teilbaum/einzeln, -g Suche, -w nur Werte, setzen mit -n Probelauf
  198. img: Test legt die GPT vor den Partitionen an (Test lief vorher nicht durch)
  199. Werkzeug fo (fortune): Spruch des Tages aus 30 eigenen Sprüchen oder eigener Sammlung
  200. Kernel: AHCI-Treiber (SATA lesen), FAT16/FAT32 mit langen Namen unter /boot (GPT/MBR), Testprogramm ck; check-boot bootet zusätzlich von GPT+FAT32-Platte und vergleicht Prüfsummen mit dem Mac
  201. Werkzeug pom (moonphase): Mondphase aus mittlerem Mondmonat (Näherung)
  202. Werkzeug cpu (lscpu/nproc): Kernarten mit Caches je Stufe, -q Kernzahl, -v Merkmale
  203. Belegt: P2 System/Prozesse (fabrik-system)
  204. Werkzeuge qt ng msg vl (fabrik-rest): Tests ok
  205. Werkzeug bnr (banner): Banner in 5x7-Schrift
  206. Werkzeug af (affinity): Kernbindung per Hex/Liste, -p, -l, -n; Mac teilweise (kein Binden)
  207. Werkzeug sid (setsid): neue Sitzung oder Gruppe, -w warten
  208. Werkzeug rsz (resizefs): Abbild vergrößern, Partition und FAT darin vergrößern/verkleinern
  209. Werkzeug un (units): Einheiten umrechnen (12 Größen, Temperatur, Daten)
  210. Werkzeug pkb (pkgbuild): .npk bauen/auflisten, Test ok (inkl. Gegenprobe mit pk)
  211. Werkzeug dm (daemon): start mit PID-Datei und Log, -r Wächter, stop mit TERM/KILL, status
  212. Werkzeug io (iostat): Datenträger-Zähler und Raten (macOS ioreg), gleich wie iostat
  213. Werkzeug ens: Belegung zurückgegeben (ausgelassen, siehe docs/fabrik/fabrik-shell.md)
  214. Werkzeug buf (stdbuf): Variablen für Pufferung setzen, libc-Auswertung offen
  215. Werkzeug lim (limits): Grenzen mit Namen zeigen und für einen Befehl setzen, -h hart, -s weich
  216. Werkzeuge prt lpm (fabrik-rest): Ports bauen, Sprachpakete über pk, Tests ok
  217. Werkzeug rp (runparts): Ordner abarbeiten (run-parts)
  218. Werkzeug lv (leave): Erinnerung zum Gehen (5 min, 1 min, jetzt, Nachfragen)
  219. Werkzeug sen (sensors): Akku, Netzteil, Leistung, Wärmewarnungen (macOS ioreg/pmset)
  220. Werkzeug lex (lexer): Scanner-Generator mit DFA und Zeichenklassen, Ausgabe gleich flex
  221. Werkzeug crt (certs): Zertifikatsspeicher mit eigenem X.509-Leser, gegen openssl geprüft; Status teilweise
  222. Belegt: swp (fabrik-hardware)
  223. Werkzeug ej (eject): auswerfen, Mac über diskutil, nullos-Entwurf
  224. Werkzeug px (procinfo): Übersicht, -f offene Dateien/Sockets, -m Speicherbereiche, -e Umgebung, -c Ordner
  225. Werkzeug wf (waitfor): Warten auf Datei, Prozess oder Uhrzeit
  226. Werkzeug sue (sudoedit): Bearbeiten über Kopie mit Zurückschreiben per rename
  227. Werkzeug lop (loop): Image ansehen (MBR/GPT), Anmelden auf dem Mac bewusst gesperrt, nullos-Entwurf
  228. Werkzeug av (antivirus): Signatursuche (Hash und Bytefolgen), EICAR-Test; Status teilweise
  229. Werkzeug dv (devices): USB/PCI/Datenträger/Netz aus ioreg, nullos-Platzhalter
  230. Werkzeug cu (serialterm): Terminal für serielle Geräte, Test mit Pseudo-Terminals ok
  231. Werkzeug trc (trace, teilweise): Verbrauchsbericht, -f abgetastete Dateien/Netz, -o Bericht in Datei
  232. Werkzeug ssh (secureshell): eigener SSH-2-Client mit curve25519, ed25519, chacha20-poly1305, strengem Schlüsseltausch; Kryptografie selbst geschrieben
  233. Werkzeug fw (firewall): Regelsprache, Prüfen, Tabelle NFW1, Paketprobe; Laden fehlt (Mac ändert nichts)
  234. Werkzeug net (network): Profile (dhcp/static/dns/wlan) und Status, auf dem Mac nur lesend
  235. Werkzeug kg (keygen): Ed25519-Schlüssel im OpenSSH-Format, Fingerabdruck, copy; teilweise (ohne Passphrase/Agent)
  236. Werkzeug atm (automount): Regeldatei, Ein-/Aushängen, Leerlauf, teilweise
  237. Werkzeuge chr (chroot) und swr (switch_root, teilweise): Prüfungen vor dem Wechsel, -n Probelauf
  238. Werkzeug dco (dircolors): LS_COLORS aus Standardtabelle oder eigener Datei
  239. Werkzeug ap (play): WAV lesen, Rate/Kanäle umrechnen, Null- und Datei-Senke, Gerät als Platzhalter
  240. Werkzeug dbg (debug): GDB-Protokoll-Client für QEMU-Stub, ELF-Symbole, Haltepunkte, Schritt, Register, Speicher; Test ok
  241. Werkzeug wl (wlan): Netzliste WPA2/WPA3, list/check/add/del, Mac-Status nur lesend
  242. Werkzeuge lpa lp (fabrik-rest): Drucker einrichten, Druckaufträge einreihen; Tests ok
  243. Werkzeug ac (audiorecord): WAV-Schreiber, Testton, PCM-Eingabe; Gerät später
  244. cc: Zufallsprogramm-Test (test/fuzz.py) gegen clang, __func__ erst bei Gebrauch
  245. Werkzeug res (resolver): Einstellungen und Zwischenspeicher zeigen, abfragen, leeren; Format und Regeln in der README
  246. Werkzeug ap: Test prüft Fehlerfälle wirklich
  247. Werkzeug bri (brightness): Helligkeit zeigen/setzen, Scheingeräte-Test, teilweise
  248. Werkzeug cfg (config): Einstellungen als eine Textdatei, Präfixe, setzen/löschen mit Erhalt von Kommentaren
  249. Werkzeug bp (beep): Ton mit Frequenz/Länge/Anzahl, Mac-Klingel, nullos-Platzhalter; fertig (Mac)
  250. Werbespruch: NULLos – no BS (Betriebssystem ohne Bullshit)
  251. Werkzeug chm (charmap): Blocktabellen, Namenssuche, Code-Info
  252. Werkzeug bdf (bindiff): Delta erzeugen/anwenden mit CRC-Prüfung; fertig (Mac)
  253. Werkzeug bsp (bootsplash): Splash-Format und Renderer, Test schreibt PPM
  254. Werkzeug rsy (rsync): lokal abgleichen mit Delta-Verfahren, --delete, -n, -c, --exclude
  255. Werkzeug acc (accounting): Abrechnung auswerten, Summen, Sätze anhängen; on/off nur Platzhalter
  256. Werkzeug kb (keyboard): Belegungen us/de, laden, zeigen, ändern, kmap-Format
  257. Werkzeug rmd (reminders): Terminkalender: heute und morgen aus Textdatei
  258. Werkzeug cap (capabilities): Modell, Anzeigen/Ablegen/Starten mit weniger (Mac simuliert), Test ok
  259. Werkzeug cg (cgroup): Gruppendefinitionen prüfen/zeigen, Probelauf; Status teilweise
  260. Werkzeug btr (btrfs): Abbild lesen – info, chunks, sub, check, dump, ls, cat
  261. Werkzeug cap: Test korrigiert (mount)
  262. Werkzeug tra (traceroute): Weg Sprung für Sprung, -l fortlaufend wie mtr, ICMP-Sonden ohne Root, -u UDP mit Root
  263. Werkzeug bta (bootanalyze): Zeitleiste, Rangliste, SVG; Vorschlag für bt]-Zeitstempel in nb/nk
  264. Werkzeug js (json): jq-Filtersprache mit eigener Regex, Formaten, Pfadzuweisungen; Test aus ~110 jq-geprüften Fällen
  265. Werkzeug ntf (notify): Textmeldung auf dem Terminal mit Protokoll
  266. Werkzeug ad (directory): LDAP-Client mit eigenem BER-Kodierer, Test gegen lokalen Antworter
  267. Werkzeug bw (bandwidth): TCP/UDP-Durchsatz, Latenz-Echo, Server und Client, Test auf 127.0.0.1
  268. Werkzeuge lpf lpd asa (fabrik-rest): Druckfilter, Druckdienst, Fortran-Vorschub; Tests ok
  269. Werkzeug cap: argv-Ende beim Entfernen der Optionen mitverschieben, Test ok
  270. Werkzeug mod (module): Module auflisten/filtern, laden/entladen mit -n Probelauf
  271. Werkzeug cns (setconsole): Systemkonsole anzeigen; Umschalten wartet auf Kernel
  272. Werkzeug cfl (cflow): Aufrufgraph aus C-Quelltext, getestet an kernel/
  273. asa: erste Zeile mit Vorschubzeichen korrigiert, Test ok
  274. Werkzeug rnd (random)
  275. Werkzeug cfe (configeditor): Baum der Einstellungen im Textmodus ansehen und ändern, Test mit Tastenfolgen
  276. rnd: -x liest direkt aus /dev/urandom
  277. Werkzeug nb (neighbors): Nachbartabelle zeigen (arp/ndp, nur lesen), Mac-Sperre dokumentiert
  278. Werkzeug bo (boot): Startpartition prüfen, nullos installieren mit Schutz fremder Bootloader
  279. Werkzeug bak (backup): dedupliziert, inhaltsbasierte Chunks, SHA-256, DEFLATE, Snapshots, restore, prune, check, Test
  280. Werkzeug uu (uuid): v1, v3, v4, v5, v7, nil/max, Lesen
  281. Werkzeug gt (gettext): Übersetzung aus PO-Textkatalogen mit Mehrzahl
  282. Werkzeuge osa, shc: Belegung zurückgegeben (ausgelassen, siehe docs/fabrik/fabrik-shell.md)
  283. Werkzeug bld (buildsys): ninja-kompatibler Bauer mit Depfiles, Pools, -j; Status fertig (Mac)
  284. Werkzeug pwr (power): Akku/Netzteil, -q Ladestand, -w wach halten, -s Ruhezustand
  285. Werkzeug dlg (dialog): Zeilen-Dialoge: Hinweis, Ja/Nein, Eingabe, Passwort, Menü, Mehrfachauswahl
  286. Werkzeug tso (toposort)
  287. Werkzeug scp (securecopy): SFTP-Client mit eigenem SSH-Transport (Ed25519, ChaCha20-Poly1305), getestet gegen lokalen sshd
  288. Werkzeug clc (calculator): Vollbild-Rechner mit Verlauf, Programmierer-Modus, Einheiten; Test ok
  289. Werkzeug exp (expect): Frage-Antwort-Automatisierung am Pseudo-Terminal
  290. Werkzeug upd (update): nullos aus Release-Ordner auf die Startpartition, .alt-Rückweg mit -z, -m macOS-Updates
  291. Werkzeug imc (imgconvert): PNG (mit Inflate), BMP, PNM, TGA lesen/schreiben, skalieren; Test mit zlib-PNGs ok
  292. pv belegen
  293. Werkzeug rs (reshape): Spalten umbrechen, transponieren, Dateien zeilenweise zusammenlegen (lam)
  294. Werkzeug pv (pipeview): Fortschritt, Rate, Restzeit, -L Ratenbegrenzung
  295. Kernel: Shell s startet als erstes Programm (exit -> Kernel-Prompt), Werkzeuge aus cmd/ mit nullos-libc in /bin (make nullos-tools), Reihenfolge-Fehler der Konsoleneingabe behoben; check-boot wartet auf den Prompt statt fester Zeiten, prüft Werkzeuge und ein Shell-Skript (39/39)
  296. Werkzeug sch (sched): Klasse/Priorität zeigen und setzen, nice + Echtzeit (Mac)
  297. Werkzeug adb (androidbridge): ADB-Client über TCP mit shell, push, pull, ls und kleinem adbd; ohne RSA-Anmeldung
  298. Werkzeug uif (unifdef): #if-Blöcke auflösen, -D/-U/-l/-i/-o, dreiwertige Ausdrücke
  299. docs/fabrik/fabrik-shell.md: Abschlussbericht der Fabrik fabrik-shell
  300. Werkzeug ts (timestamp): Zeitstempel vor jede Zeile, -i/-s/-m/-u, %.S
  301. Werkzeug sld (syslogd): Protokoll-Dienst mit Zeitstempel und Rotation, -m als logger, -e Fehler
  302. Werkzeug pli (plist): XML/binär/JSON lesen, schreiben, umwandeln, ändern; Test gegen plutil
  303. Werkzeug pc (pcap): pcap/pcapng lesen und schreiben, Ethernet/ARP/IP/ICMP/UDP/TCP/DNS/DHCP zerlegen, Filter
  304. Werkzeug clk (clock): Weltzeit, Stoppuhr, Timer, Wecker, eigene Zonentabelle mit Sommerzeit
  305. Werkzeuge iv scr (fabrik-rest): Terminal-Bildanzeige, Bildspeicher als Bild; Tests ok
  306. Werkzeug vis (visible): Steuerzeichen sichtbar machen, -t -e -u; Status fertig (Mac)
  307. Werkzeug dmm (devmem): Speicher/Register lesen und schreiben, Maske, Auszug, Abbilddatei-Test
  308. Werkzeug i2c (i2c): scan, dump, get, set, xfer; simulierter Bus am Mac, Platzhalter für nullos
  309. libc: eigene C-Bibliothek mit host-Backend (macOS ohne libSystem), 33/33 Werkzeug-Tests grün
  310. libc: nullos-Backend (x86_64, docs/syscalls.md), open-Schalter in derselben Schreibweise wie include/nullos/sys.h
  311. libc: scanf, getline, getopt, popen, realpath, mkstemp, posix_spawn (ohne fork), pwd/grp, poll/select, mmap, uname u. a.
  312. Werkzeug spi (spi): SPI-Rohtransfer und W5500-Befehle, simulierter W5500 am Mac
  313. Werkzeug ser (serial): Baud, Rahmen, Flusssteuerung anzeigen und setzen, getestet am Pseudo-Terminal
  314. Werkzeug gp (gpio): Pins zeigen/lesen/setzen/beobachten, Software-PWM; Mac-Simulator getestet, ESP32-Register ungeprüft
  315. check-boot: Tastatur (PS/2, IRQ 1) über den QEMU-Monitor geprüft (40/40); Kernel-README zum Testablauf
  316. Werkzeug tpm (tpm): TPM 2.0 rand, pcr, caps, banks; gegen swtpm getestet
  317. Werkzeug ssd (sshserver): SSH-2-Server mit curve25519-sha256, ssh-ed25519, chacha20-poly1305, Schlüsselanmeldung, pty mit s, exec; Krypto selbst geschrieben und gegen RFC-Vektoren geprüft, 26 KB je Verbindung
  318. Werkzeug fnt (consolefont): Linienschrift ansehen, prüfen, Kleinbuchstaben und Umlaute
  319. Werkzeug wg (wireguard): Schlüssel, Konfiguration, Noise_IKpsk2-Handschlag im Userspace, getestet
  320. Werkzeug prf (profile): stat, Probenauswertung (top/fold/flame-SVG), Entwurf für Proben auf nullos
  321. cc: Umwandlung kleiner Typen mit anderem Vorzeichen (gefunden mit test/fuzz.py); Assembler: Makros, .rept/.if/.set, Steuer-/Segmentregister, lgdt/lidt/ltr/invlpg, fxsave, push imm/mem, %gs:
  322. Werkzeug cx (cppcompile): C++-Teilmenge nach C, Klassen, Vorlagen, virtuelle Funktionen, iostream
  323. Werkzeug brn (burn): ISO 9660 + Joliet + El Torito schreiben, auflisten, in Datei brennen
  324. Werkzeug vc (versioncontrol): Git-kompatible Versionsverwaltung von null an
  325. cc: neuer Kernel (obere Hälfte, isr.S) mit eigener Werkzeugkette: __attribute__((aligned/packed)) überall, Assembler mit „;“, Marke vor Makro; kernel.sh nach Makefile-Liste
  326. check-boot: Laufzeit unter 1 s ohne führende Null (sonst Oktalfehler in $((...))), gemeldet von der cc-Session
  327. libc: math.h (fdlibm-Verfahren, ≤1–3 ulp gegen macOS gemessen), TZ-Wechsel zur Laufzeit, TIOCSWINSZ, sethostname, memset_pattern16
  328. Release: init.img (/bin, Werkzeuge) und alle Dateien aus build/esp/nullos ins Abbild, eigener Boot-Test mit Programmen und /boot (SATA)
  329. cc: nullos-Benutzerprogramme mit cc: kernel/user/* gebaut mit eigenem Assembler/Linker laufen unter dem cc-Kernel, check-boot.sh komplett grün; Registervariablen für asm
  330. Systemaufrufe Fassung 2 (Wünsche der libc): poll, times (Rechenzeit je Prozess), F_DUPFD, Zugriffszeit in chtime; utest 66/66, make check 40/40 mit der libc von main (277 Werkzeuge in /bin)
  331. Kernel-README: utest hat 65 Fälle (nachgezählt)
  332. libc: nullos-Backend auf docs/syscalls.md Fassung 2 – poll (und select darüber), times für getrusage/clock, F_DUPFD direkt, chtime mit atime
  333. Doku: Stand 23 Uhr – Shell und Werkzeuge laufen auf nullos, libc, Kernel (Prozesse, 44 Syscalls, AHCI/FAT), Treiber, Editor e, Release-Abbilder und Installer, nullos.de statt muehlbronner.de, ESP32-C5, cc RISC-V; Chronik
  334. FAT: in der GPT zuerst die EFI-Systempartition suchen, Basic data nur ohne ESP (Hybrid-ISO als Platte: /boot fehlte), gemeldet von der Release-Session
  335. cc: nullos-libc und 280 Werkzeuge mit cc gebaut laufen auf dem cc-Kernel (Werkzeug- und Shell-Test grün)
  336. cc läuft auf nullos: übersetzt dort mit eigenem Assembler/Linker und nullos-libc ein C-Programm, das richtig läuft (make nullos)
  337. cc übersetzt sich auf nullos selbst: cc2 entsteht auf nullos und übersetzt das Testprogramm richtig (make nullos)
  338. Werkzeug bas (basic): BASIC-Interpreter, Test grün
  339. Werkzeug doc (docconvert): Markdown nach HTML, Text und Handbuchseite
  340. Werkzeug mst (ministat): Statistik und Student-t-Test für Messreihen
  341. Werkzeug spc (spell): Rechtschreibprüfung mit DAWG-Wörterbuch, Vorschlägen nach Editierabstand, Komposita; Status fertig (Mac)
  342. Werkzeug osa (scripthost): Interpreter nach #!-Zeile oder Endung wählen, -l/-e/-n/-v; Status fertig (Mac)
  343. Werkzeug rds (sessions): Sitzungen zeigen (utmpx, Mac nur lesen), -e beenden/-n Probe, -i Testquelle
  344. Werkzeug cor (coredump): nullos-Core-Format (ELF ET_CORE), Anzeiger, Schreiber; Ziehen fremder Prozesse fehlt noch
  345. Werkzeug rk (radiokill): WLAN/Bluetooth listen, Probelauf; Mac nur lesend
  346. Werkzeug he (hexedit): Hex-Editor mit Seek-Lesen, Überlagerung, Suchen, Gehe zu, Undo; Status fertig (Mac)
  347. Werkzeug tyc (typec): USB-C-Quelle, Leistung und PD-Profile (Mac: ioreg, nullos: Platzhalter)
  348. Werkzeug lpt (lptport): Parallelport-Einstellungen, Mac nur Trockenlauf; Test ok
  349. Werkzeug vt (vtswitch): Konsolen anzeigen/wechseln/starten/freigeben, Mac-Probelauf
  350. Release: CD-Startabbild unter der El-Torito-Grenze von 32 MiB halten, check-release meldet fehlenden Prompt sofort
  351. Werkzeug rf (roff): man(7)- und mdoc(7)-Seiten für das Terminal setzen, getestet gegen mandoc
  352. Doku: cc läuft auf nullos und übersetzt sich dort selbst, ganz nullos mit cc gebaut (selbst geprüft mit make -C cc nullos); Chronik
  353. Werkzeug kx (kexec): ELF-Prüfung, bootinfo-Vorlage, flaches Abbild; Sprung wartet auf SYS_KEXEC
  354. Belegt: wp lt rec (fabrik-system)
  355. Werkzeug nf (numfmt)
  356. Werkzeug wp (waitpid): auf fremde Prozesse warten, kqueue auf dem Mac, -a -t -v
  357. Werkzeug krb (kerberos): ccache lesen/schreiben/löschen, MIT v4 + krb1; Status teilweise
  358. Werkzeug lu (lookup)
  359. Werkzeug lt (loadtest): CPU-/Speicher-/Plattenlast mit Messwerten
  360. Werkzeug rdp (remotedesktop): RFB-Client und -Server, fertig (Mac)
  361. rdp: Test auf Rundung der 16-Bit-Farbe korrigiert
  362. Werkzeug col (colfilter)
  363. Werkzeug rpc (rpcinfo): Portmapper dump/port/ping über TCP
  364. Werkzeug nfs (nfsinfo): Exporte und Clients per Portmapper/MOUNT abfragen
  365. nfs: Test ohne Terminated-Meldung
  366. Werkzeug rec (script): Sitzung im Pseudo-Terminal aufnehmen, -p mit Zeitablauf abspielen, -s Tempo
  367. Belegt: fwa lr si (fabrik-system)
  368. Werkzeug pgn (paginate)
  369. Werkzeug dhs (dhcpserver): DHCPv4-Server mit Adressbereich, festen Zuordnungen, Lease-Datei, DISCOVER/REQUEST/DECLINE/RELEASE/INFORM
  370. Werkzeug uc (charinfo)
  371. Werkzeug fwa (filewatch): Änderungen melden (kqueue), -r, -1, -t, -e Befehl wie entr
  372. Werkzeug lr (logrotate): ab Größe drehen, -k alte behalten, -c kopieren und leeren
  373. Werkzeug pwg (pwgen)
  374. Werkzeug smb (smbclient): SMB2/2.1 mit NTLMv2, ls/get/put, Test gegen lokalen Testserver; teilweise
  375. Werkzeug si (sysinfo): Systembericht in einem Blick, -s Abschnitt
  376. Belegt: ipo crs nmo (fabrik-system)
  377. Werkzeug ph (passhash): crypt $1$ $5$ $6$ erzeugen und prüfen
  378. Werkzeug ptx (permindex): Stichwort-im-Zusammenhang, vereinfacht
  379. Werkzeug ipo (ipcs/ipcmk/ipcrm): IPC-Objekte zeigen, anlegen, mit ART:ID löschen
  380. Werkzeug crs (crashreport): Absturzberichte auflisten, -v mit Ausnahme und Aufrufkette samt Quellzeile
  381. Werkzeug mim (mime): Nachrichten bauen, listen, auspacken
  382. mim: Test ohne Nebenausgabe
  383. Werkzeug nmo (netmon): Durchsatz je Schnittstelle live mit 64-Bit-Zählern
  384. Fabrik fabrik-text: Abschlussbericht
  385. Belegt: restliche P3 System (fabrik-system)
  386. Werkzeug hng (hangdiag): Prozess abtasten, schwerster Pfad je Thread, häufigste Stapelspitzen
  387. Werkzeug nv (nvram): Firmware-Variablen zeigen (lesbar dekodiert), setzen/löschen mit -n
  388. Werkzeug wdg (watchdog, teilweise): Prüfbefehl mit Fehlergrenze und Aktion, -s Hardware-Zustand
  389. Werkzeug pers (arch/setarch): Architektur zeigen, Befehl als x86_64 (Rosetta) oder arm64 starten
  390. pers: Test ohne Fehlermeldung in der Ausgabe
  391. Werkzeug ns (namespace, teilweise): ohne Netz (-n) und Schreiben nur in einem Ordner (-w)
  392. ns: Test prüft Netz-Sperre gegen eigenen Lauscher
  393. smb: md, rm, mv (Ordner anlegen, löschen, umbenennen), Test erweitert
  394. Werkzeug dhs: DHCPv6 (IA_NA und zustandslos), Server-DUID und v6-Leases in der Lease-Datei, Tests auf ::1
  395. smb: SMB2-Signatur (HMAC-SHA256, Sitzungsschlüssel aus NTLMv2), Testserver prüft sie
  396. arc, hs, en, zp: Status-Zeile ergänzt (Tests laufen: ok)
  397. lib/rand.h aus den Zufallskopien (rnd, sf, uu, pwg); Bericht ergänzt
  398. Werkzeug rpc: Härtung (Fragmentgrenze, Längenprüfung, Portprüfung), Test

29.10.2026

  1. nfs: Kernel-Zähler (-s Client wie nfsstat -c, -S Server-Einstellungen)
  2. krb: README Befund Apple-klist
  3. Werkzeug kx (kexec): Test deckt Überlappung, zu viele Segmente, zu großes Abbild ab
  4. Werkzeug kx (kexec): Test deckt alle Prüfungen und Aufruffehler ab
  5. Regel: alle Netzwerk-Werkzeuge mit IPv6 (Dual-Stack, AAAA, Tests auf ::1)
  6. Werkzeug rdp (remotedesktop): Anmeldung Benutzer+Passwort (ARD) und VNC-Passwort, eigene DES/AES/MD5/DH
  7. Werkzeug swp (swap): Auslagerung anzeigen (macOS), Linux-Swap anlegen; dsk.c erkennt Swap-Namen
  8. Werkzeug ql (quicklook): Dateityp erkennen, Kurzinfos, Textvorschau; Test ok
  9. Werkzeug wip (wipefs): Kennungen von Dateisystemen und Tabellen finden und löschen
  10. Werkzeug tun (tunefs): FAT-Kenndaten zeigen, Seriennummer und Zustandsmerker setzen
  11. Werkzeug cb (clipboard): Ablage privat unter ~/.clipboard (0600), Verweise und offene Rechte abgelehnt, Test
  12. Werkzeug rdp: IPv4 und IPv6 gleichwertig (::1]:port, Doppelbuchse), Test auf ::1
  13. fabrik-netz: P1-Liste der Kategorie Netzwerk fertig, Stand und Vorschlag lib/net.h

28.10.2026

  1. py: Zwischenstand (Kern, Zahlen, Parser, Übersetzer – noch nicht lauffähig)
  2. py: erster lauffähiger Stand (Parser, Übersetzer, VM, Grundtypen)

29.10.2026

  1. Werkzeug py (python): eigener Python-Interpreter, Testsammlung ok
  2. dns: IPv6 – Test-Server auch auf ::1 (UDP, TCP, gekürzt), -6 mit Servername
  3. Werkzeug rcv (recover): gelöschte FAT-Dateien finden, retten, wiederherstellen (Name über LFN-Prüfsumme)
  4. Werkzeuge mid mxr (fabrik-rest): MIDI lesen, Mixerzustand; Tests ok
  5. nc: IPv6 – Adressen in ], Tests für Dual-Stack-Lauschen, UDP und -z über ::1
  6. Belegt: smt dbf tri dfr (fabrik-hardware)
  7. Werkzeug ff (mediaconvert): WAV umwandeln (Rate, Kanäle, Bittiefe); Test ok
  8. ssh: IPv6 – Rechner als ::1] und NAME@::1], Test mit sshd auch auf ::1
  9. sid: immer abspalten, ohne -w sofort zurück; Tests sid/lim robuster; docs/fabrik/fabrik-system.md: Abschlussbericht
  10. Werkzeuge mp say (fabrik-rest): Medienverteiler, Sprachausgabe (Mac); Tests ok
  11. Bildschirmfoto: nullos 0.2 in QEMU mit Shell s und Werkzeugen aus /bin
  12. obj: Disassembler für x86_64 (-d), gleich llvm-objdump bei allen cc- und clang-Objekten
  13. Werkzeug err (errno): Fehlercodes und Signale von nullos erklären
  14. net.h: IPv6-Bereich für link-lokale Adressen (fe80::1%en0), net_same, net_udp_join, klare Meldung ohne Schnittstelle; in allen Netz-Werkzeugen der Fabrik, Tests pi/nc mit fe80::1%lo0
  15. Werkzeug idt (ident): RCS- und SCCS-Kennzeichen in Dateien finden
  16. Werkzeuge dvf wds (fabrik-rest): Prüfsummenliste, Startdateien übertragen; Tests ok
  17. Werkzeuge wsa fca (fabrik-rest): Leistungsmessung, Schriftenindex; Tests ok
  18. Werkzeug elf (elfbrand): EI_OSABI zeigen und setzen
  19. Doku: Python-Interpreter py, neues Bildschirmfoto auf der Startseite, IPv6-Regel bei Mitmachen; Chronik
  20. Werkzeug smt (smart): Datenträger-Zustand und SMART-Status (macOS ioreg/diskutil)
  21. fs: Boottest prüft selbst (USB-Start bis Prompt, SATA: FAT32 unter /boot, nk.elf-Hash) statt check-boot.sh
  22. Werkzeug vm (virtualmachine): QEMU-Maschinen beschreiben/starten; Test ok
  23. Werkzeug tst (testrun): Testskripte finden, parallel ausführen, zusammenfassen
  24. dh: DHCPv6-Client (-6): SOLICIT/ADVERTISE/REQUEST/REPLY, DUID-LL, DNS und Domäne; getestet auf ::1 und gegen dhs
  25. px, trc: Socket-Adressen mit IPv6 (::1]:port) und IPv4 gleichwertig, Tests auf ::1; ns: Netzsperre auch auf ::1 getestet
  26. Werkzeug ctr (container): Wurzelordner-Container mit eigener Umgebung; Test ok, Status teilweise
  27. Werkzeug dbf (debugfs): FAT untersuchen (ls, stat, Ketten, cat) und ändern (mkdir, rm)
  28. docs/fabrik/fabrik-system.md: IPv6-Stand
  29. Werkzeug mkd (makedepend): #include-Abhängigkeiten für make
  30. libc: termios-Geschwindigkeiten und cfmakeraw/tcflush/tcdrain (cu), test-tools.sh robuster (Zeitgrenze, keine Rohr-Hänger, nicht gebaute Werkzeuge getrennt gezählt)
  31. Werkzeug wsu (winsetup): nullos-Wurzel einrichten, Pakete installieren; Test ok
  32. Werkzeug tri (trim): freie FAT-Cluster freigeben (Löcher per F_PUNCHHOLE) oder nullen
  33. tp: Test prüft Sortierung statt „Dauerlast steht oben“ (auf ausgelasteter Maschine nicht garantiert)
  34. Werkzeug pkc (pkgconfig): .pc-Dateien, Requires, Fassungen, --static
  35. Werkzeug fe (fileexplorer): Dateimanager als Befehlsschale; Test ok, Status teilweise
  36. Werkzeuge sts evv (fabrik-rest): Einstellungen mit Prüfung, Protokollanzeige; Tests ok
  37. Werkzeug dfr (defrag): zerstückelte FAT-Dateien zusammenhängend umlegen
  38. Werkzeug ipc (ipcalc): Netz, Maske, Bereich, Art, Teilnetze für IPv4 und IPv6
  39. Belegt: cnv bt dsp (fabrik-hardware)
  40. Werkzeug tag (ctags): tags/TAGS für C, Shell und make
  41. ABI-Aufräumen (fabrik-rest): strdup/strncat/access/ungetc/atol durch erlaubte Aufrufe ersetzt; alle Tests ok
  42. Werkzeug bt (bluetooth): Steuerbaustein und Geräte anzeigen (macOS system_profiler)
  43. Werkzeug wis (whois): RFC 3912 mit Verweisen über IANA, Server über IPv4 und IPv6
  44. Werkzeug pnt (paint): Zeichnen per Befehlsskript; Test ok, Status teilweise
  45. ssd: IPv6 – Dual-Stack ohne -l, -l nimmt IPv4/IPv6/::1]/Namen, Gegenstellen als ::1]:port, Test über ::1
  46. scp: IPv6 – ::1]:pfad und name@::1]:pfad, known_hosts als host]:port, Test mit sshd auf ::1
  47. rsy, kg: README – kein Netzteil, IPv6-Hinweis für spätere Fernübertragung
  48. Werkzeug cxr (cxref): Querverweise für C mit Funktion und Definitionen
  49. Werkzeuge sto mmc (fabrik-rest): Programmladen und Verwaltungskonsole in Textform; Tests ok
  50. Werkzeug dsp (display): Grafik und Bildschirme anzeigen (macOS system_profiler)
  51. Werkzeug cnv (convertfs): FAT12/16/32 untereinander umwandeln, Inhalt/Name/Seriennummer bleiben
  52. Belegt: snp cry (fabrik-hardware)
  53. Werkzeug htp (httpd): Dateien über HTTP/1.1, Dual-Stack, Range, Ordnerliste, Schutz vor ..; Test über 127.0.0.1 und ::1
  54. py: mehr Tests (Zahlen, Text, Klassen, Ausnahmen, Generatoren, Container), GC-Stresstest, Fehler behoben
  55. Werkzeug fm (filemanager): Ordnerübersicht in Textform; Test ok, Status teilweise
  56. Werkzeug snp (snapshot): APFS-Schnappschüsse anzeigen (macOS diskutil)
  57. Werkzeug dsk (disks): MBR/GPT und Dateisysteme erkennen; Test ok (GPT mit part), Status teilweise
  58. bw: IPv6 – Dual-Stack-Server, -s ADRESSE, Ziel als ::1]:PORT, Auflösung über AAAA; Test TCP/UDP über ::1
  59. rdp: IPv6 – vnc://::1]:PORT, Port geprüft, Meldungen mit ]; Tests über ::1, set -e-Fallen behoben
  60. wg: IPv6 – Dual-Stack-UDP, Endpoint v6]:port, alle Adressen reihum, AllowedIPs v4/v6 streng geprüft; Handschlag über ::1 getestet
  61. adb: IPv6 – Seriennummer ::1]:port, Daemon auf 127.0.0.1 und ::1, -a ::/::1; Tests über ::1
  62. Werkzeug scn (portscan): TCP-Verbindungstest eines Rechners, IPv4/IPv6, Dienstnamen
  63. Werkzeug cry (cryptdisk): FileVault-Status, LUKS1/2- und BitLocker-Köpfe erkennen und zeigen
  64. Fabrik-Bericht fabrik-hardware: 25 Werkzeuge, bootfähiger Stick, Auslassungen, Wünsche
  65. Werkzeug dmg (demangle): Itanium-C++-Namen, 95 % gleich llvm-cxxfilt bei libc++-Symbolen
  66. py: Tests für Import, Dateien, dataclasses/enum/…; Importe GC-sicher, os.stat_result, time.struct_time
  67. Werkzeug isv (inetd): Programm je TCP-Verbindung, Dual-Stack, Umgebung wie tcpsvd
  68. smb: IPv6 – smb://::1]:port, ::1 ohne Klammern, UNC-Form ipv6-literal.net, Responder auf 127.0.0.1 und ::1; alle Dateibefehle über beide getestet
  69. rpc: IPv6 – ::1]:port, rpcbind v3/v4 mit Universaladressen und netid tcp6, Rückfall auf v2; Test über 127.0.0.1, ::1], localhost
  70. nfs: IPv6 – ::1], rpcbind GETADDR mit tcp6, mehrere Aufrufe je Verbindung; Testserver auf beiden Familien
  71. ad: IPv6 – ldap://::1]:port, ::1 ohne Klammern, Testserver auf 127.0.0.1 und ::1; Test-Rückgabe 143 behoben
  72. py: REPL vervollständigt Modulnamen und setzt ( nach aufrufbaren Attributen; Vorauseingaben bleiben erhalten
  73. docs/fabrik/fabrik-rest.md: Formate, fertig/teilweise/ausgelassen, Wünsche (fabrik-rest)
  74. Werkzeug mdn (mdns): Dienste und Namen per mDNS/DNS-SD über 224.0.0.251 und ff02::fb
  75. Werkzeug mck (memcheck): x86_64-Nachbildung mit eigener Halde, findet Überläufe, Zugriff nach free, doppeltes free, Lecks
  76. obj: Kommentar in x86dis.c (Kopie liegt in cmd/mck)
  77. dbg: IPv6 – -p ::1]:PORT und ::1 ohne Port, Meldung mit ]; Test-Stub auf ::1, Test-Rückgabe behoben
  78. nt: IPv6 – Server als ::1] und ::1]:PORT; SNTP-Testserver auf ::1, Test-Rückgabe behoben
  79. tpm: IPv6 – Simulator-Adresse über getaddrinfo (A und AAAA), ::1]:PORT; Test mit swtpm auf ::1
  80. tra: IPv6 – net.h auf Stand von cmd/pi (Bereich fe80::1%lo0, net_same); Tests link-lokal, -6 localhost, -l ::1
  81. pc: IPv6 – DHCPv6 entschlüsseln und filtern, multicast-Filter für IPv4/IPv6-Gruppen; Test mit v6.pcap
  82. Werkzeug dtr (dtrace): Systemaufrufe, Funktionsbaum, Zählung und Befehlsprofil über die mck-Nachbildung
  83. fw: IPv6 – ::1] und ::ffff:a.b.c.d in Regeln, icmp/icmp6 passend zur Familie; IPv6-Regelsatz im Test, set -e-Fallen behoben
  84. nb: IPv6 – Suche vergleicht Adressen statt Text (fe80::1], fe80::1%en0, Großschreibung); Test mit NDP-Beispiel
  85. res: IPv6 – Server fe80::1%en0 erlaubt, Adressen streng geprüft; Tests mit IPv6-Servern
  86. wl: IPv6 – Status zeigt alle Adressen (IPv4, globale IPv6); Test-Eingang WL_IFCONFIG, set -e-Fallen behoben
  87. net: IPv6 – address/gateway je IPv4 und IPv6, fe80::1%en0 als Gateway/DNS, Status mit IPv6-Standardroute
  88. si: Test prüft globale IPv6-Adresse im Bericht
  89. hw: hexv nach plat_host.c (nur dort gebraucht) – baut jetzt auch für nullos ohne Warnung
  90. Werkzeug bld: ungenutzte Variable nstat entfernt (nullos-Build)
  91. Werkzeug nbd: NBD-Server und Lese-/Schreib-Client (fixed newstyle), Dual-Stack, ::1]:PORT
  92. Werkzeug he: lseek+read/write statt pread/pwrite (abi.md), baut für nullos
  93. si: size_str nur im Host-Zweig genutzt, Warnung im nullos-Bau beseitigt
  94. tp, log, trc, si: bauen für nullos; tp läuft dort interaktiv (termios, poll, Fenstergröße) mit Kernen, Gesamtspeicher, Laufzeit; si mit uname/sysconf
  95. py: datetime, csv, argparse, pathlib, hashlib (md5/sha1/sha2 in C), base64, fractions, statistics, shlex, pprint, getopt
  96. h: gepackte Hilfedaten als /sys/hilfe in die initrd (in QEMU geprüft: h c, h -s tar, h tar)
  97. py: continue/break/return im finally verwerfen einen anstehenden Rückgabewert; Semantik-Tests
  98. fabrik-netz: IPv6-Prüfung aller Netz-Werkzeuge, neue Werkzeuge ipc wis htp scn isv mdn nbd, net.h mit Bereich
  99. Werkzeug ind (indent): Einrückung im nullos-Stil, 73 % der cmd/-Quellen exakt wiederhergestellt
  100. Werkzeug ma (mail): SMTP senden über IPv4/IPv6, mbox lesen; Schutz gegen eingeschleuste Befehle
  101. py: eingebaute Methoden erst beim ersten Zugriff anlegen (Startspeicher 127 KB -> 90 KB), PYMEMSTAT
  102. docs/fabrik/fabrik-system.md: Stand nullos-Bau
  103. Werkzeug lip (lipo): Mach-O-Universaldateien, Byte für Byte wie lipo
  104. py: async/await, async with/for, eigenes asyncio (Aufgaben, Zeitgeber, gather, Queue, Lock, Event, wait_for)
  105. Werkzeug ra (routeradv): gelernte IPv6-Router und Präfixe (wie ndp -r/-p), Router-Solicitation
  106. py: Zwischenspeicher für Attributsuche je Klasse, Rahmen-Vorrat (OOP-Code ~1,5x schneller); Programm-Tests
  107. Werkzeug eth (ethtool): Art, Verbindung, Medium, Duplex, MTU, Zähler; MTU setzen
  108. s: Zeileneditor auf der nullos-Konsole: keine %-Zeile mehr (nur bei xterm & Co.), kein doppeltes Neuzeichnen bei Enter, Marke nur relativ bewegen (Ausgabe ohne Zeilenende wird nicht überschrieben), mehrzeilige PS1
  109. eth: Warnung bei MTU unter 1280 (kein IPv6)
  110. Doku: h mit Hilfe auf nullos, libc-Testzahl; neu generiert
  111. Werkzeug dtc (devicetree): dts <-> dtb mit Marken, phandles, Overlays per &marke, /bits/, Ausdrücken
  112. Tastatur: deutsche Belegung als Standard (AltGr, Feststelltaste, Umlaute als UTF-8), umschaltbar mit kb
  113. py: unittest, subprocess, tempfile, threading, queue, weakref, timeit, inspect, platform, uuid, secrets, locale; help()
  114. py: Schutz gegen tiefe C-Rekursion (repr, ==, hash, Parser) mit RecursionError/SyntaxError statt Absturz

28.10.2026

  1. tp: Test beendet Dauerlast-Prozesse auch bei Fehlschlag

29.10.2026

  1. ql: tr im Test mit LC_ALL=C, Zufallsbytes sind kein UTF-8 (tr: Illegal byte sequence)
  2. ser: Pseudo-Terminal-Helfer vor „ok“ beenden, sonst steht „Terminated“ hinter ok und der Test zählt als rot
  3. Abgleich: nacheinander bauen (schont den Mac), IPv6-Regel prüfen, Belegungen ohne Code auflisten
  4. Abgleich Runde 3: 263 fertig (Mac), 116 teilweise, 5 in Arbeit, 2 ausgelassen, 23 offen; keine roten Tests, make check ok
  5. Werkzeug rcs (oldvcs): ci/co/log/diff im RCS-Format mit Rückwärts-Deltas und Schlüsselwörtern
  6. Werkzeug ppp: HDLC-Rahmen, LCP, IPCP und IPV6CP aushandeln; nur IPv6 möglich; Test zwei ppp über FIFOs
  7. py: listint] als GenericAlias, genaue Unicode-Fehlermeldungen, Randfall-Tests
  8. fabrik-netz: ma, ra, eth, ppp ergänzt; qos und ucp mit Grund ausgelassen
  9. py: -m führt das Modul nur einmal als __main__ aus; os.environ gibt Änderungen an die Umgebung weiter; REPL- und -m-Test
  10. py: ExceptionGroup/BaseExceptionGroup (bei Bedarf angelegt)
  11. Werkzeug sgn (sign): signify-kompatibel mit Ed25519, gleich RFC 8032 und OpenSSL
  12. Fabrik fabrik-dev: Abschlussbericht (20 fertig, 5 teilweise, 4 ausgelassen)
  13. py: alle 635 Dateien der CPython-3.15-Standardbibliothek übersetzen fehlerfrei (lazy import, type-Anweisung, Typparameter, t-Strings, verschachtelte f-Strings nach PEP 701, __mro_entries__)
  14. Bildschirmfoto: nullos 0.2 mit 387 Werkzeugen, Hilfe, Python, Rechner
  15. py: abc mit register/__subclasshook__, numbers, codecs, contextvars, sys.hash_info; Gleichheit bei Metaklassen ohne Endlosschleife; tests/cpython.sh lässt CPythons eigene Module laufen
  16. py: Klassenrumpf schreibt in __prepare__-Namensräume über __setitem__, type(name, bases, ns) nimmt die Metaklasse der Basen; CPythons enum.py läuft unverändert
  17. py: int|str (UnionType), sentinel(), gettext, _weakref, collections.abc mit Mixin-Methoden, __hash__=None bei list/dict/set; CPythons copy/functools/argparse/collections laufen
  18. py: 64-Bit-Werte auf 32-Bit-Rechnern nicht abschneiden (mkint64); Grenzen als Makros (PY_MIN_HEAP, PY_MAX_DEPTH, PY_MAX_CFRAMES), PYHEAP
  19. py: Exit-Code 130 bei Abbruch mit Strg-C
  20. py: except* (ExceptionGroups aufteilen, Rest und Ausnahmen aus Behandlern weiterreichen)
  21. py: t-Strings mit string.templatelib (Template, Interpolation, convert)
  22. Sockets Fassung 3: Vertrag (Aufrufe 46–61, Werte wie libc/Linux) und Loopback im Kernel, IPv4 und IPv6 gleichwertig
  23. py: ast.literal_eval, copyreg; CPythons pprint läuft
  24. py: Interning-Tabelle schwach (dynamische Namen belegen keinen Speicher auf Dauer)
  25. libc: Sockets (IPv4+IPv6, BSD-API), eigener Namensauflöser (hosts, DNS A+AAAA, PTR), getifaddrs; sigaction, sigprocmask, wait4, getrlimit, chroot, pty, sys/param.h
  26. libc: nullos-Backend nutzt die Socket-Aufrufe aus docs/syscalls.md Fassung 3 (46–61), Systemaufruf mit 6 Argumenten
  27. py: bytes % Formatierung; Rahmenvorrat kleiner (PY_FRAME_POOL)
  28. py: zlib und gzip (DEFLATE aus zp, Kopie in cmd/py/zc), mit CPython austauschbar
  29. py: README-Stand und offene Punkte
  30. Doku: Python auf nullos, Sockets (IPv4/IPv6, Loopback), 62 Systemaufrufe, deutsche Tastatur und UTF-8-Bildschirm; Chronik
  31. Netzwerkkarten: virtio-net und e1000 (82540EM/82545EM/82574L), Netz-Thread, geteilte PCI-Leitungen
  32. TCP/IP-Stapel: IPv6 und IPv4 gleichwertig über virtio-net und e1000 (ND, SLAAC, RDNSS, DHCPv6, ARP, DHCPv4, ICMP, UDP, TCP)
  33. Netztest mit zwei nullos an einer Leitung: TCP über verbindungslokales IPv6 aktiv und passiv (ntest -l/-c)
  34. initrd: /etc/hosts (localhost für 127.0.0.1 und ::1) und kleine /etc/services (IANA-Nummern)
  35. libc: exp10/__exp10 (nf), Ziel testbins (Selbsttests als bin/libc-netz, bin/libc-eigen für make check)
  36. Doku: Netzwerkkarten und eigener TCP/IP-Stapel (IPv6+IPv4); Chronik