create-adr-app 0.0.0-stage → 0.1.0

package/template/app/[lang]/adrs/llm-training-adr/decisions-dictionaries/de.json

@@ -0,0 +1,215 @@
+{
+  "considerations": "Überlegungen",
+  "label_what": "Was",
+  "label_why": "Warum",
+
+  "section_title_software": "Software",
+  "section_title_modular_stack": "Infrastruktur & Laufzeit-Stack",
+
+  "tensorflow_title": "TensorFlow",
+  "tensorflow_desc": "Eine End-to-End-Open-Source-Plattform für maschinelles Lernen, die umfassende Ökosysteme aus Werkzeugen, Bibliotheken und Community-Ressourcen bietet, um ML-gestützte Anwendungen zu erstellen und bereitzustellen.",
+  "tensorflow_link_github": "GitHub-Repository",
+  "tensorflow_link_doc": "Offizielle Dokumentation",
+
+  "jax_title": "JAX",
+  "jax_desc": "Eine Open-Source-Bibliothek für numerische Berechnungen mit hoher Leistung und maschinelle Lernforschung, die Hardwarebeschleunigung für nativen Python- und NumPy-Code über automatische Differenzierung und Kompilierungs-Wrapper bereitstellt.",
+  "jax_link_doc": "Offizielle Dokumentation",
+
+  "flax_title": "Flax",
+  "flax_desc": "Ein flexibles und leistungsstarkes Ökosystem für neuronale Netzwerkbibliotheken, das speziell für JAX entwickelt wurde, um Entwicklern klare, modifizierbare Pfade für das Zustands- und Parametermanagement zu bieten.",
+  "flax_link_github": "GitHub-Repository",
+  "flax_link_doc": "Flax ReadTheDocs",
+
+  "modularTitle": "Modular",
+  "modularDesc": "Inferenz neu gedacht, vom Kernel bis zur Cloud. Ein einheitlicher Stack.\nIhre Modelle, jede Rechenleistung, eine Plattform. Führen Sie KI über GPUs und CPUs hinweg aus – entwickelt für die anspruchsvollsten Inferenz-Workloads, vom Kernel bis zur Cloud.",
+  "modularLinkHome": "Modular",
+
+  "servingTitle": "Serving",
+  "servingDesc": "Unser leistungsstarkes, hardwareunabhängiges Serving-Framework, MAX, optimiert Kernel und die Ausführung von Abfragen automatisch über Beschleuniger hinweg. 2-fache Leistungssteigerung gegenüber vLLM auf unterschiedlichster Hardware durch einen einzigen Container und eine OpenAI-kompatible API.",
+
+  "modelingTitle": "Modellierung",
+  "modelingDesc": "Führen Sie über 1000 Modelle wie DeepSeek und Kimi direkt mit MAX aus. PyTorch-ähnliche Modell-APIs und KI-Codierungsfunktionen machen es einfach, maßgeschneiderte Modelle in wenigen Minuten zu portieren.",
+
+  "gpuKernelsTitle": "GPU-Kernel",
+  "gpuKernelsDesc": "Hunderte von hochmodernen, kombinierbaren Kerneln, geschrieben in unserer leistungsstarken System-Programmiersprache Mojo. Erweitern oder schreiben Sie benutzerdefinierte GPU-Kernel für maximale Leistung auf allen Beschleunigern.",
+
+  "hardwareCompatibilityTitle": "Hardware-Kompatibilität",
+  "hardwareCompatibilityDesc": "Modular wurde von Grund auf so entwickelt, dass es nativ heterogen ist. Führen Sie Workloads nahtlos auf NVIDIA-, AMD- und Apple-GPUs sowie auf Intel-, AMD- und ARM-CPUs aus.",
+
+  "mojoTitle": "Mojo",
+  "mojoDesc": "Schreiben wie in Python, ausführen wie in C++.\nSchreiben Sie schnellen Code für unterschiedlichste Hardware, von CPUs bis zu GPUs, ohne Vendor-Lock-in – in einer Sprache, die sowohl benutzerfreundlich als auch speichersicher ist.",
+  "mojoLinkSite": "Mojo",
+
+  "maxTitle": "MAX",
+  "maxDesc": "GenAI-natives Serving und Modellierung, gebaut für Performance.\nEinmal entwickeln, überall bereitstellen mit einem einzigen programmierbaren Stack für hochperformante GenAI auf jeder Hardware.",
+  "maxLinkOss": "MAX",
+
+  "selfHostedTitle": "Selbstgehostetes MAX + Mojo",
+  "selfHostedDesc": "Offene Infrastruktur. Volle Kontrolle, völlig kostenlos.\nStellen Sie MAX und Mojo auf Ihrer eigenen Infrastruktur bereit – ein einziger Open-Source-Container unter 700 MB, der auf NVIDIA, AMD, Apple und weiteren Plattformen läuft. Schreiben Sie eigene Serving-Layer, Modelle und Kernel, profilieren Sie Workloads und optimieren Sie jede Ebene. Werden Sie noch heute Teil unserer Open-Source-KI-Community.",
+  "selfHostedLinkGuide": "Selbstgehostetes MAX + Mojo",
+
+  "modular-infra_title": "Modular-Infrastruktur-Ökosystem",
+  "modular-infra_desc": "Eine einheitliche Systemausführungsebene, die für die komplexe Modellkompilierung und -verarbeitung entwickelt wurde. Sie führt Modellbewertungs-Workflows nahtlos über heterogene Verarbeitungsknoten hinweg aus einer einzigen lokalen Quellcodebasis aus.",
+  "modular-infra_link_home": "Modular Homepage",
+
+  "serving-engine_title": "Hochleistungs-Serving-Engine",
+  "serving-engine_desc": "Ein hardware-agnostisches Framework für die Bereitstellung von Anfragen, das darauf ausgelegt ist, Operations-Kernel und Ausführungswarteschlangen lokal zu optimieren. Es bedient verschiedene Modelltypen über einen standardisierten, selbstgehosteten Container unter Verwendung lokaler API-Protokolle.",
+
+  "modeling-layer_title": "Modellanpassungs- und Übersetzungsschichten",
+  "modeling-layer_desc": "Integrierte Modellprogrammierschnittstellen, mit denen benutzerdefinierte Softwarearchitekturen in wenigen Minuten in ausführbare lokale Bereitstellungsformate portiert, evaluiert und kompiliert werden können.",
+
+  "gpu-kernels_title": "Benutzerdefinierte GPU-Kompilierungen & Ausführungs-Kernel",
+  "gpu-kernels_desc": "Abstrakte, zusammensetzbare Kompilierungsschichten, die direkt auf parallelen Hardwarebeschleunigern laufen. Diese Konfiguration ermöglicht es Entwicklern, mathematische Logikgrenzen zu erweitern oder benutzerdefinierte Rechenaufgaben zu erstellen, um die Leistung zu maximieren.",
+
+  "hardware-compatibility_title": "Heterogene Hardware-Interoperabilität",
+  "hardware-compatibility_desc": "Eine strukturelle Rechenschicht, die entwickelt wurde, um Aufgaben nahtlos über verschiedene Grafikarchitekturen und Verarbeitungssysteme hinweg auszuführen, wodurch die Abhängigkeit von bestimmten Chipsatz-Anbietern eliminiert wird.",
+
+  "mojo_title": "Kompilierung von System-Programmiersprachen (Mojo)",
+  "mojo_desc": "Eine Hochleistungs-Systemprogrammiersprache, welche die Zugänglichkeit moderner Skriptsyntax mit der Geschwindigkeit, Speichersicherheit und Layoutkontrolle nativer, niedrigerer Quellcodekompilierung kombiniert.",
+  "mojo_link_site": "Mojo Lang Webseite",
+
+  "max_title": "Inferenz-Engine-Architektur (MAX)",
+  "max_desc": "Ein leistungsorientiertes Serving- und Modellierungssubsystem, das entwickelt wurde, um lokalisierte mathematische Ausführungsschritte einheitlich auf verschiedenen selbstgehosteten Setups zu erstellen und bereitzustellen.",
+  "max_link_oss": "MAX Open Source",
+
+  "self-hosted_title": "Selbstgehostete Plattform-Bereitstellungs-Engine",
+  "self-hosted_desc": "Ein isoliertes Laufzeitkonfigurationspaket unter 700 MB für selbstgehostete Datennetzwerke. Es ermöglicht lokales Profiling, die Erstellung benutzerdefinierter Schichten und die vollständige Kontrolle über Systemhardwareschichten ohne externe Verbindungen.",
+  "self-hosted_link_guide": "Leitfaden für Selbsthoster",
+
+  "section_title_gpu_compatibility": "Modular MAX GPU-Kompatibilität",
+  "link_label_gpu_packages": "GPU-Kompatibilität",
+  "link_label_nvidia_gpus": "NVIDIA-GPUs",
+  "link_label_amd_gpus": "AMD-GPUs",
+  "gpu_table_label_gpu": "GPU",
+  "gpu_table_label_architecture": "Architektur",
+  "gpu_table_group_tested": "Für Serving getestet",
+  "gpu_table_group_compatible": "Bekannt kompatibel für Entwicklung",
+  "gpu_nvidia_driver_note": "Software-Anforderung: NVIDIA-GPU-Treiber 580 oder neuer. Überprüfen Sie Ihre Version mit nvidia-smi. Informationen zur Aktualisierung finden Sie in der NVIDIA-Treiberdokumentation. Wenn Ihr Treiber älter als 580 ist, setzen Sie die Umgebungsvariable MODULAR_NVPTX_COMPILER_PATH auf eine systemeigene ptxas-Binärdatei (Beispiel: export MODULAR_NVPTX_COMPILER_PATH=/usr/local/cuda/bin/ptxas).",
+  "gpu_amd_driver_note": "Software-Anforderung: AMD-GPU-Treiber 6.3.3 oder neuer (MI355X erfordert ROCm 7.0 oder neuer). Informationen zur Installation finden Sie im nativen Ubuntu-Installationsleitfaden.",
+
+  "use-cases": "Anwendungsfälle",
+  "section_title_use_cases": "Generative KI",
+  "section_title_agentic_ai": "Agentische KI",
+  "section_title_resources": "Ressourcen",
+  "btn_example": "Beispiel",
+
+  "code-generation_title": "Code-Generierung (Coding Agent)",
+  "code-generation_desc": "Automatisierte Erstellung, Überprüfung und kontinuierliche Verfeinerung von Softwarecode durch mehrstufige Modell-Evaluierungszyklen unter Nutzung optimierter Kompilierungstechniken für schnelle Ausführungsschleifen.",
+  "code-generation_badge_1": "Automatisierte Überprüfung",
+  "code-generation_badge_2": "Schnelle Ausführungsschleifen",
+
+  "image-generation_title": "Bildgenerierung",
+  "image-generation_desc": "Erstellung hochwertiger visueller Inhalte und maßgeschneiderter Grafiken aus Textbeschreibungen, optimiert für maximalen Verarbeitungsdurchsatz auf unterschiedlichen Infrastrukturen.",
+  "image-generation_badge_1": "Text-zu-Bild",
+  "image-generation_badge_2": "Hoher Durchsatz",
+
+  "video-generation_title": "Videogenerierung",
+  "video-generation_desc": "Produktion synthetisierter bewegter Videosequenzen direkt aus Open-Weight-Modellen auf Standard-Infrastrukturen, um Abhängigkeiten von proprietären externen Systemen zu eliminieren.",
+  "video-generation_badge_1": "Videosynthese",
+  "video-generation_badge_2": "Infrastruktur-Unabhängigkeit",
+
+  "text-to-speech_title": "Text-zu-Audio (Text-to-Speech)",
+  "text-to-speech_desc": "Konvertierung von geschriebenem Text in natürlich klingende Sprachaudiodaten mit minimaler Berechnungsverzögerung, was eine einheitliche Ausführung auf unterschiedlichen Host-Hardware-Setups ermöglicht.",
+  "text-to-speech_badge_1": "Natürliche Sprachausgabe",
+  "text-to-speech_badge_2": "Geringe Berechnungsverzögerung",
+
+  "agentic-ai-core_title": "Agentische KI",
+  "agentic-ai-core_desc": "Bereitstellung grundlegender Ausführungssysteme für autonome Softwareeinheiten, die zu mehrstufigem logischem Denken, struktureller Planung und programmatischer Tool-Nutzung in lokalen Umgebungen fähig sind.",
+  "agentic-ai-core_badge_1": "Autonomes Denken",
+  "agentic-ai-core_badge_2": "Tool-Integration",
+
+  "custom-models_title": "Maßgeschneiderte Modelle",
+  "custom-models_desc": "Entwicklung und Bereitstellung maßgeschneiderter Modellarchitekturen auf Kernel-Ebene über variierende Hardware-Umgebungen hinweg unter Verwendung einer einzigen, einheitlichen Codebasis zur Eliminierung von Plattformabhängigkeiten.",
+  "custom-models_badge_1": "Architektur auf Kernel-Ebene",
+  "custom-models_badge_2": "Einheitliche Codebasis",
+
+  "workflow-automation_title": "Workflow-Automatisierung",
+  "workflow-automation_desc": "Verkettung aufeinanderfolgender Systemaufrufe zur Bewältigung komplexer Backend-Automatisierungssequenzen – einschließlich Dokumentenanalyse, programmatischer Datenleitung, Validierung und Korrekturmechanismen.",
+  "workflow-automation_badge_1": "Mehrstufige Automatisierung",
+  "workflow-automation_badge_2": "Sequenzielle Validierung",
+
+  "ai-coding-agents_title": "KI-Programmieragenten",
+  "ai-coding-agents_desc": "Ausführung dichter, iterativer Programmierschleifen für das Erstellen, Testen und Debuggen von Anwendungen in Echtzeit über lokalisierte, kompilierte Verarbeitungsprotokolle.",
+  "ai-coding-agents_badge_1": "Iterative Erstellung",
+  "ai-coding-agents_badge_2": "Lokalisierte Kompilierung",
+
+  "voice-to-action_title": "Sprach-zu-Aktion-Agenten",
+  "voice-to-action_desc": "Konsolidierung von Spracherkennung, semantischem Parsing, Backend-Tool-Ausführung und Sprachausgabegenerierung in einer einheitlichen Datenverarbeitungspipeline zur Eliminierung von Übertragungsverzögerungen.",
+  "voice-to-action_badge_1": "Einheitliche Sprach-Pipeline",
+  "voice-to-action_badge_2": "Echtzeit-Interaktion",
+
+  "on-device-agents_title": "On-Device-Agenten",
+  "on-device-agents_desc": "Ausführung in sich geschlossener logischer Modelle direkt auf Endgeräten, sodass komplexe Softwareprozesse ohne externe Serverabhängigkeiten vollständig offline funktionieren können.",
+  "on-device-agents_badge_1": "Lokale Edge-Ausführung",
+  "on-device-agents_badge_2": "Offline-Funktionalität",
+
+  "multi-agent-orchestration_title": "Multi-Agenten-Orchestrierung",
+  "multi-agent-orchestration_desc": "Koordinierung von Netzwerken spezialisierter Modelle, die dynamisch kommunizieren, unter Verwendung strukturierter Systemsicherheitsgrenzen und zentraler Planungsroutinen zur Erreichung einheitlicher Ziele.",
+  "multi-agent-orchestration_badge_1": "Modellkoordination",
+  "multi-agent-orchestration_badge_2": "Zentrale Ablaufplanung",
+
+  "model-library_title": "Modellbibliothek",
+  "model-library_desc": "Zugriff auf und Bereitstellung eines kuratierten Katalogs unterstützter Open-Source-Modelle in Sekundenschnelle vor Ort, welcher als standardisiertes Evaluierungszentrum für selbstgehostete Ausführungsumgebungen dient.",
+  "model-library_badge_1": "Offene Modelle",
+  "model-library_badge_2": "Lokale Bereitstellung",
+
+  "hardware-selection-and-sourcing": "Hardware-Auswahl und -Beschaffung",
+  "hardware-selection-and-sourcing_what": "Die erste strategische Phase zur Bewertung und zum Kauf physischer Computerkomponenten auf der Grundlage der Workload-Anforderungen.",
+  "hardware-selection-and-sourcing_why": "Das KI-Training erfordert intensive Rechenressourcen. Die frühzeitige Auswahl der richtigen Prozessoren, Beschleuniger und schnellen Speicher verhindert Projektengpässe und vermeidet die Verschwendung von Kapital für inkompatible Komponenten.",
+
+  "hardware-setup": "Hardware-Einrichtung",
+  "hardware-setup_what": "Der Prozess des Zusammenbaus physischer Computerkomponenten, der Einrichtung geeigneter Kühlsysteme und des Anschlusses der Stromversorgung.",
+  "hardware-setup_why": "Komplexe Berechnungen erzeugen hohe Hitze und verbrauchen erhebliche Mengen an Strom. Eine ordnungsgemäße Montage verhindert physische Schäden, Überhitzung und instabile Systemabstürze während aufeinanderfolgender Tage unter Dauerlast.",
+
+  "software-selection": "Software-Auswahl",
+  "software-selection_what": "Der Schritt zur Erforschung und Auswahl von Programmiersprachen, Software-Engines und Toolchains für den Workflow.",
+  "software-selection_why": "Verschiedene Software-Werkzeuge interagieren unterschiedlich mit der Computerhardware. Die Auswahl optimierter Systeme stellt sicher, dass mathematische Operationen direkt in Hardware-Aktionen übersetzt werden, ohne Ausverzögerungen zu verursachen.",
+
+  "software-setup": "Software-Einrichtung",
+  "software-setup_what": "Der Prozess der Installation von Betriebssystemen, des Flashens von Treibern, des Abgleichs von Konfigurationspfaden und der Vorbereitung von Software-Tools.",
+  "software-setup_why": "Computer können abstrakte KI-Frameworks nicht automatisch mit roher elektronischer Hardware verbinden. Die ordnungsgemäße Einrichtung stellt die grundlegende Kommunikationsverbindung zwischen Code-Bibliotheken und Ausführungsprozessoren her.",
+
+  "llm-architecture-definition": "Definition der LLM-Architektur",
+  "llm-architecture-definition_what": "Der mathematische Blaupause und das Code-Layout, die Größe, Form, Datenpfade und die interne Struktur des Netzwerks definieren.",
+  "llm-architecture-definition_why": "Dies bestimmt die grundlegende Intelligenzkapazität des Modells. Es legt fest, wie Eingangsdaten durch die Schichten fließen, und steuert, wie Parameter Informationen verarbeiten, ohne die physischen Speichergrenzen zu überschreiten.",
+
+  "data-preparation": "Datenvorbereitung",
+  "data-preparation_what": "Die Verarbeitungspipeline zum Bereinigen von Textdaten, Entfernen von Duplikaten, Überprüfen auf Formatierungsfehler und Strukturieren von Informationen für die Verarbeitung.",
+  "data-preparation_why": "KI-Modelle sind Reflexionssysteme, welche die exakten Eigenschaften der aufgenommenen Daten erben. Saubere Daten lehren das Netzwerk logische Muster, während fehlerhafte Daten dazu führen, dass Kapazitäten für das Auswendiglernen von Rauschen verschwendet werden.",
+
+  "training-setup": "Training-Einrichtung",
+  "training-setup_what": "Konfigurieren der Parameter der Lernschleife, Auswahl der mathematischen Methoden zur Fehlerverfolgung und Einrichtung von Routinen zur Speicheroptimierung.",
+  "training-setup_why": "Die Berechnung mathematischer Änderungen über Milliarden von Punkten erfordert eine enorme Menge an Arbeitsspeicher. Eine korrekte Konfiguration schafft Optimierungsleitplanken, um den Systemhintergrundspeicher stabil zu halten.",
+
+  "pre-training": "Pre-Training",
+  "pre-training_what": "Die Brain-Lernphase, in der das Modell rohe, allgemeine Textdaten in massivem Umfang liest, um allgemeine Grammatik und grundlegende Logikmuster zu lernen.",
+  "pre-training_why": "Hier entwickelt ein untrainiertes neuronales Netzwerk sein grundlegendes Sprachverständnis. Die Verarbeitung riesiger Datenmengen ermöglicht es dem Modell, Syntax, Definitionen und allgemeine Denkmuster aufzunehmen.",
+
+  "launching-training-execution-run": "Start des Trainingslaufs",
+  "launching-training-execution-run_what": "Kompilieren des Codes, Starten der aktiven Datenladeströme und Ausführen der Live-Verarbeitungsschleife auf der Hardware.",
+  "launching-training-execution-run_why": "Dies ist der aktive Produktionsschritt, in dem der Computer die eigentlichen Lernberechnungen durchführt. Er erfordert eine reibungslose Ablaufverfolgung und einen stabilen Speicherzugriff, um die Hardware kontinuierlich auszulasten.",
+
+  "alignment-and-post-training": "Alignment und Post-Training",
+  "alignment-and-post-training_what": "Der Prozess der Feinabstimmung eines vortrainierten Modells mit gezielten Anweisungsskripten oder Sicherheitsrichtlinien, um dessen Ausgabe von Antworten zu modifizieren.",
+  "alignment-and-post-training_why": "Ein reines, vortrainiertes Basismodell beherrscht nur die Autovervollständigung von Texten. Das Alignment formt das Modell zu einem reaktionsschnellen, sicheren Assistenten, der direkte Benutzerfragen beantworten kann.",
+
+  "evaluation-and-benchmarking": "Evaluierung und Benchmarking",
+  "evaluation-and-benchmarking_what": "Testen des fertigen Netzwerks anhand standardisierter Fragensätze, um Genauigkeit, Logikgeschwindigkeit und Leistung zu verfolgen.",
+  "evaluation-and-benchmarking_why": "Dies zeigt, ob der Trainingslauf erfolgreich war. Es markiert präzise, wo das Netzwerk echtes Verständnis zeigt, und hebt Bereiche hervor, in denen Fehler oder Halluzinationen auftreten.",
+
+  "compilation": "Kompilierung",
+  "compilation_what": "Der Schritt, bei dem Software-Tools abstrakte mathematische Schichten in hocheffiziente Maschinenbefehle für eine bestimmte Chipklasse übersetzen.",
+  "compilation_why": "Der rohe Modellcode enthält einen hohen Abstraktions-Overhead. Die Kompilierung verdichtet Berechnungen in einheitliche, effiziente Schritte, welche die volle Geschwindigkeit der Zielhardware freisetzen.",
+
+  "optimization": "Optimierung",
+  "optimization_what": "Anwendung von Geschwindigkeitsverbesserungen, Komprimierungsroutinen oder spezialisierten Token-Prüfschleifen zur Beschleunigung von Antworten.",
+  "optimization_why": "Dieser Schritt maximiert die Leistungseffizienz, sodass das Modell Eingaben schneller verarbeiten und qualitativ hochwertigere Ausgaben generieren kann, ohne dass teure Hardware-Upgrades erforderlich sind.",
+
+  "deployment": "Bereitstellung",
+  "deployment_what": "Paketierung der kompilierten Modelldatei und deren Übertragung in eine Produktionsumgebung, wie einen Webserver oder eine lokale Anwendungsschnittstelle.",
+  "deployment_why": "Dies führt das Modell aus einem isolierten Entwicklungslabor in einen aktiven Zustand über, in dem es Endbenutzern dienen, Live-Fragen annehmen und auf externe Anfragen reagieren kann.",
+
+  "inference": "Inferenz",
+  "inference_what": "Der Live-Anwendungsmodus, in dem ein bereitgestelltes Modell eine eingehende Benutzereingabe verarbeitet und eine Text- oder Code-Antwort in Echtzeit generiert.",
+  "inference_why": "Dies ist das endgültige Ziel des gesamten KI-Entwicklungslebenszyklus. Da die rechenintensiven Trainingsvariablen wegfallen, verbraucht die Inferenz nur minimalen Speicher, um sofortige Antworten zu liefern."
+}

package/template/app/[lang]/adrs/llm-training-adr/decisions-dictionaries/en.json

@@ -0,0 +1,215 @@
+{
+  "considerations": "Considerations",
+  "label_what": "What",
+  "label_why": "Why",
+
+  "section_title_software": "Software",
+  "section_title_modular_stack": "Infrastructure & Runtime Stack",
+
+  "tensorflow_title": "TensorFlow",
+  "tensorflow_desc": "An end-to-end open-source platform for machine learning, providing comprehensive ecosystems of tools, libraries, and community resources to build and deploy ML-powered applications.",
+  "tensorflow_link_github": "GitHub Repository",
+  "tensorflow_link_doc": "Official Documentation",
+
+  "jax_title": "JAX",
+  "jax_desc": "An open-source library designed for high-performance numerical computing and machine learning research, bringing hardware acceleration to native Python and NumPy code via automated differentiation and compilation wrappers.",
+  "jax_link_doc": "Official Documentation",
+
+  "flax_title": "Flax",
+  "flax_desc": "A flexible and high-performance neural network library ecosystem built explicitly for JAX, designed to provide developers with clear, modifiable state and parameter management paths.",
+  "flax_link_github": "GitHub Repository",
+  "flax_link_doc": "Flax ReadTheDocs",
+
+  "modularTitle": "Modular",
+  "modularDesc": "Inference reimagined, from Kernel to Cloud.One unified stack.\nYour model, any compute, one platform. Run AI across GPUs and CPUs - engineered for the most demanding inference workloads, from kernel to cloud.",
+  "modularLinkHome": "Modular",
+
+  "servingTitle": "Serving",
+  "servingDesc": "Our high-performance, hardware-agnostic serving framework, MAX, automatically optimizes kernels and request execution across accelerators. 2x performance improvement over vLLM on diverse hardware through a single container and OpenAI-compatible API.",
+
+  "modelingTitle": "Modeling",
+  "modelingDesc": "Run 1000+ models like DeepSeek and Kimi out of the box with MAX. PyTorch-like model APIs and AI coding skills make it easy to port custom models in minutes.",
+
+  "gpuKernelsTitle": "GPU Kernels",
+  "gpuKernelsDesc": "100s of SOTA, composable kernels written in our high-performance systems language, Mojo. Extend or write custom GPU kernels for maximum performance across accelerators.",
+
+  "hardwareCompatibilityTitle": "Hardware Compatibility",
+  "hardwareCompatibilityDesc": "Modular was built to be natively heterogeneous. Run workloads seamlessly across NVIDIA, AMD, and Apple GPUs as well as Intel, AMD, and ARM CPUs.",
+
+  "mojoTitle": "Mojo",
+  "mojoDesc": "Write like Python, run like C++.\nWrite fast code for diverse hardware, from CPUs to GPUs, without vendor lock-in, in a language that's both user friendly and memory safe.",
+  "mojoLinkSite": "Mojo",
+
+  "maxTitle": "MAX",
+  "maxDesc": "GenAI-native serving and modeling, built for performance.\nBuild once, deploy anywhere with a single programmable stack for high-performance GenAI on any hardware",
+  "maxLinkOss": "MAX",
+
+  "selfHostedTitle": "Self-Hosted MAX + Mojo",
+  "selfHostedDesc": "Open infrastructure. Full control, made free.\nDeploy MAX and Mojo on your infrastructure - one open-source container under 700MB that runs on NVIDIA, AMD, Apple & more. Write custom serving layers, models, kernels, profile workloads, and optimize every layer. Join our open source AI community today.",
+  "selfHostedLinkGuide": "Self-Hosted MAX + Mojo",
+
+  "modular-infra_title": "Modular Infrastructure Ecosystem",
+  "modular-infra_desc": "A unified system execution tier engineered to handle complex model compilation and processing. It runs model evaluation workflows fluidly across heterogeneous processing nodes from a single local source codebase.",
+  "modular-infra_link_home": "Modular Home",
+
+  "serving-engine_title": "High-Performance Serving Engine",
+  "serving-engine_desc": "A hardware-agnostic request serving framework built to optimize operation kernels and request execution queues locally. It serves diverse model types through a standardized self-hosted container using local API protocols.",
+
+  "modeling-layer_title": "Model Adaptability & Translation Layers",
+  "modeling-layer_desc": "Integrated model programming interfaces that allow custom software architectures to be ported, evaluated, and compiled into runnable local deployment formats within minutes.",
+
+  "gpu-kernels_title": "Custom GPU Compilations & Execution Kernels",
+  "gpu-kernels_desc": "Low-level, composable compilation layers running directly on parallel hardware accelerators. This configuration allows developers to extend mathematical logic boundaries or build custom computing tasks to maximize performance.",
+
+  "hardware-compatibility_title": "Heterogeneous Hardware Interoperability",
+  "hardware-compatibility_desc": "A structural computing layer built to execute tasks seamlessly across various graphics architectures and processing systems, eliminating dependency on specific chipset vendors.",
+
+  "mojo_title": "Systems Language Compilation (Mojo)",
+  "mojo_desc": "A high-performance systems programming language that combines the accessibility of modern scripting syntax with the speed, memory safety, and layout control of native lower-level source compilation.",
+  "mojo_link_site": "Mojo Lang Site",
+
+  "max_title": "Inference Engine Architecture (MAX)",
+  "max_desc": "A performance-focused serving and modeling subsystem designed to construct and deploy localized mathematical execution steps uniformly on diverse self-hosted setups.",
+  "max_link_oss": "MAX Open Source",
+
+  "self-hosted_title": "Self-Hosted Platform Deployment Engine",
+  "self-hosted_desc": "An isolated runtime configuration package built under 700MB for self-hosted data networks. It enables local profiling, custom layer composition, and full control over system hardware layers without external connections.",
+  "self-hosted_link_guide": "Self-Hosted Guide",
+
+  "section_title_gpu_compatibility": "Modular MAX GPU Compatibility",
+  "link_label_gpu_packages": "GPU Compatibility",
+  "link_label_nvidia_gpus": "NVIDIA GPUs",
+  "link_label_amd_gpus": "AMD GPUs",
+  "gpu_table_label_gpu": "GPU",
+  "gpu_table_label_architecture": "Architecture",
+  "gpu_table_group_tested": "Tested for serving",
+  "gpu_table_group_compatible": "Known compatible for development",
+  "gpu_nvidia_driver_note": "Software requirement: NVIDIA GPU driver 580 or later. Check your version with nvidia-smi. To update, see the NVIDIA driver docs. If your driver is older than 580, set the MODULAR_NVPTX_COMPILER_PATH environment variable to a system ptxas binary (for example, export MODULAR_NVPTX_COMPILER_PATH=/usr/local/cuda/bin/ptxas).",
+  "gpu_amd_driver_note": "Software requirement: AMD GPU driver 6.3.3 or later (MI355X requires ROCm 7.0 or later). For installation, see the Ubuntu native install guide.",
+
+  "use-cases": "Use Cases",
+  "section_title_use_cases": "Generative AI",
+  "section_title_agentic_ai": "Agentic AI",
+  "section_title_resources": "Resources",
+  "btn_example": "Example",
+
+  "code-generation_title": "Code Generation (Coding Agent)",
+  "code-generation_desc": "Automated generation, review, and continuous refinement of software code through multi-step model evaluation cycles, utilizing optimized compilation techniques to maintain rapid execution loops.",
+  "code-generation_badge_1": "Automated Review",
+  "code-generation_badge_2": "Fast Execution Loops",
+
+  "image-generation_title": "Image Generation",
+  "image-generation_desc": "Creation of high-quality visual assets and custom graphics from text descriptions, optimized to achieve maximum processing throughput across diverse infrastructure setups.",
+  "image-generation_badge_1": "Text-to-Image",
+  "image-generation_badge_2": "High Throughput",
+
+  "video-generation_title": "Video Generation",
+  "video-generation_desc": "Production of synthesized motion video sequences directly from open-weight models on standard infrastructure, eliminating dependencies on proprietary external systems.",
+  "video-generation_badge_1": "Motion Video Synthesis",
+  "video-generation_badge_2": "Infrastructure Independence",
+
+  "text-to-speech_title": "Text to Audio (Text-to-Speech)",
+  "text-to-speech_desc": "Conversion of written text into natural-sounding voice audio with minimal computational delay, ensuring unified execution across different host hardware setups.",
+  "text-to-speech_badge_1": "Natural Voice Audio",
+  "text-to-speech_badge_2": "Low Computational Delay",
+
+  "agentic-ai-core_title": "Agentic AI",
+  "agentic-ai-core_desc": "Deploying foundational execution systems for autonomous software units capable of multi-step logical reasoning, structural planning, and programmatic tool utilization across local environments.",
+  "agentic-ai-core_badge_1": "Autonomous Reasoning",
+  "agentic-ai-core_badge_2": "Tool Integration",
+
+  "custom-models_title": "Custom Models",
+  "custom-models_desc": "Developing and deploying bespoke, kernel-level model architectures across varying hardware environments using a single, unified codebase to eliminate vendor platform dependencies.",
+  "custom-models_badge_1": "Kernel-Level Architecture",
+  "custom-models_badge_2": "Unified Codebase",
+
+  "workflow-automation_title": "Workflow Automation",
+  "workflow-automation_desc": "Chaining successive system calls to handle complex backend automation sequences—including document analysis, programmatic data routing, validation, and correction mechanisms.",
+  "workflow-automation_badge_1": "Multi-Step Automation",
+  "workflow-automation_badge_2": "Sequential Validation",
+
+  "ai-coding-agents_title": "AI Coding Agents",
+  "ai-coding-agents_desc": "Executing dense iterative programming loops for real-time application building, testing, and debugging via localized compiled processing protocols.",
+  "ai-coding-agents_badge_1": "Iterative Building",
+  "ai-coding-agents_badge_2": "Localized Compilation",
+
+  "voice-to-action_title": "Voice to Action Agents",
+  "voice-to-action_desc": "Consolidating speech recognition, semantic parsing, backend tool execution, and voice output generation into a unified data processing pipeline to eliminate transmission latencies.",
+  "voice-to-action_badge_1": "Unified Voice Pipeline",
+  "voice-to-action_badge_2": "Real-Time Interaction",
+
+  "on-device-agents_title": "On-device Agents",
+  "on-device-agents_desc": "Running self-contained logical models locally on edge consumer devices, allowing complex software processes to function completely offline without external server dependencies.",
+  "on-device-agents_badge_1": "Local Edge Execution",
+  "on-device-agents_badge_2": "Offline Functionality",
+
+  "multi-agent-orchestration_title": "Multi-agent Orchestration",
+  "multi-agent-orchestration_desc": "Coordinating networks of specialized models that communicate dynamically, utilizing structured system safety boundaries and central scheduling routines to complete unified objectives.",
+  "multi-agent-orchestration_badge_1": "Model Coordination",
+  "multi-agent-orchestration_badge_2": "Central Scheduling",
+
+  "model-library_title": "Model Library",
+  "model-library_desc": "Accessing and deploying a curated catalog of supported open-source frontier models locally in seconds, serving as the standardized evaluation hub for self-hosted execution environments.",
+  "model-library_badge_1": "Open Models",
+  "model-library_badge_2": "Local Deployment",
+
+  "hardware-selection-and-sourcing": "Hardware selection and sourcing",
+  "hardware-selection-and-sourcing_what": "The initial strategic phase for evaluating and purchasing physical computer components based on workload demands.",
+  "hardware-selection-and-sourcing_why": "AI training requires intense computational resources. Choosing the right processors, accelerators, and fast memory upfront prevents project bottlenecks and avoids wasting capital on incompatible components.",
+
+  "hardware-setup": "Hardware setup",
+  "hardware-setup_what": "The process of assembling physical computing parts, arranging proper cooling systems, and connecting electrical power.",
+  "hardware-setup_why": "Heavy computations generate high heat and draw significant amounts of electricity. Proper assembly prevents physical damage, overheating, and unstable system crashes during consecutive days of continuous load.",
+
+  "software-selection": "Software selection",
+  "software-selection_what": "The step for researching and selecting the programming languages, software engines, and library toolchains for the workflow.",
+  "software-selection_why": "Different code tools interact with computer hardware differently. Selecting optimized systems ensures that mathematical operations translate directly into hardware actions without introducing execution lag.",
+
+  "software-setup": "Software setup",
+  "software-setup_what": "The process of installing operating systems, flashing drivers, matching configuration paths, and preparing software tools.",
+  "software-setup_why": "Computers cannot automatically bridge abstract AI frameworks to raw electronic hardware. Proper setup establishes the foundational communication link between code libraries and execution processors.",
+
+  "llm-architecture-definition": "LLM architecture definition",
+  "llm-architecture-definition_what": "The mathematical blueprint and code layout that defines the size, shape, data pathways, and internal layout of the network.",
+  "llm-architecture-definition_why": "This dictates the raw intelligence capacity of the model. It maps how input data flows through layers and guides how parameters process information without overwhelming physical memory limits.",
+
+  "data-preparation": "Data Preparation",
+  "data-preparation_what": "The processing pipeline for cleaning text data, removing duplicates, check for formatting errors, and structuring information for ingestion.",
+  "data-preparation_why": "AI models are reflection engines that inherit the exact characteristics of the ingestion data. Clean data teaches the network logical patterns, while noisy data forces it to waste capacity memorizing clutter.",
+
+  "training-setup": "Training setup",
+  "training-setup_what": "Configuring the parameters of the learning loop, selecting error-tracking mathematics, and setting up memory-optimizing routines.",
+  "training-setup_why": "Calculating mathematical changes across billions of points requires a massive amount of working memory. Proper configuration creates optimization guardrails to keep system memory stable.",
+
+  "pre-training": "Pre-training",
+  "pre-training_what": "The primary learning phase where the model reads raw, generic text data at a massive scale to learn general grammar and foundational logic patterns.",
+  "pre-training_why": "This is where a blank neural network develops its baseline understanding of language. Processing huge volumes of data allows the model to absorb syntax, definitions, and generic reasoning patterns.",
+
+  "launching-training-execution-run": "Launching training execution run",
+  "launching-training-execution-run_what": "Compiling the code, spinning up active data loading streams, and running the live processing loop across the hardware.",
+  "launching-training-execution-run_why": "This is the active production step where the computer performs the actual learning computations. It requires smooth execution tracking and steady storage access to keep the hardware continuously saturated.",
+
+  "alignment-and-post-training": "Alignment and post-training",
+  "alignment-and-post-training_what": "The process of fine-tuning a pre-trained model with targeted instruction scripts or safety guidelines to modify its output behavior.",
+  "alignment-and-post-training_why": "A baseline pre-trained model only autocompletes text. Alignment shapes the model into a responsive, safe assistant capable of answering direct user queries.",
+
+  "evaluation-and-benchmarking": "Evaluation and benchmarking",
+  "evaluation-and-benchmarking_what": "Testing the completed network against standardized question sets to track accuracy, logic speed, and performance.",
+  "evaluation-and-benchmarking_why": "This determines if the training run was successful. It pinpoints where the network shows true understanding and highlights where it outputs mistakes or hallucinations.",
+
+  "compilation": "Compilation",
+  "compilation_what": "The step where software tools translate abstract mathematical layers into highly efficient machine instructions built for a specific chip class.",
+  "compilation_why": "Raw model code contains high abstraction overhead. Compiling condenses calculations into unified, efficient steps that unlock the full speed of the targeted hardware.",
+
+  "optimization": "Optimization",
+  "optimization_what": "Applying speed enhancements, compression routines, or specialized token checking loops to accelerate responses.",
+  "optimization_why": "This step maximizes performance efficiency, allowing the model to process inputs quickly and generate higher-quality outputs without requiring expensive hardware upgrades.",
+
+  "deployment": "Deployment",
+  "deployment_what": "Packaging the compiled model file and transferring it into a production environment, such as a web server or a local application interface.",
+  "deployment_why": "This moves the model out of an isolated development lab into an active state where it can serve end-users, accepting live questions and responding to outside requests.",
+
+  "inference": "Inference",
+  "inference_what": "The live application mode where a deployed model processes an incoming user input prompt and generates a real-time text or code response.",
+  "inference_why": "This is the final objective of the entire AI engineering lifecycle. Because the heavy training variables are dropped, inference uses minimal memory to deliver immediate answers."
+}

package/template/app/[lang]/adrs/llm-training-adr/llm-training-adrs-list.tsx

@@ -0,0 +1,106 @@
+import { AdrsList } from "@/app/[lang]/types/adr";
+
+export const LLMTrainingAdrsList: AdrsList = [
+  {
+    translationKey: "use-cases",
+    link: "/adrs/llm-training-adr/decisions/use-cases",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "considerations",
+    link: "/adrs/llm-training-adr/decisions/considerations",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "hardware-selection-and-sourcing",
+    link: "/adrs/llm-training-adr/decisions/hardware-selection-and-sourcing",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "hardware-setup",
+    link: "/adrs/llm-training-adr/decisions/hardware-setup",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "software-selection",
+    link: "/adrs/llm-training-adr/decisions/software-selection",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "software-setup",
+    link: "/adrs/llm-training-adr/decisions/software-setup",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "llm-architecture-definition",
+    link: "/adrs/llm-training-adr/decisions/llm-architecture-definition",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "data-preparation",
+    link: "/adrs/llm-training-adr/decisions/data-preparation",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "training-setup",
+    link: "/adrs/llm-training-adr/decisions/training-setup",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "pre-training",
+    link: "/adrs/llm-training-adr/decisions/pre-training",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "launching-training-execution-run",
+    link: "/adrs/llm-training-adr/decisions/launching-training-execution-run",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "alignment-and-post-training",
+    link: "/adrs/llm-training-adr/decisions/alignment-and-post-training",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "evaluation-and-benchmarking",
+    link: "/adrs/llm-training-adr/decisions/evaluation-and-benchmarking",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "compilation",
+    link: "/adrs/llm-training-adr/decisions/compilation",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "optimization",
+    link: "/adrs/llm-training-adr/decisions/optimization",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "deployment",
+    link: "/adrs/llm-training-adr/decisions/deployment",
+    date: "May 2026",
+    status: "Draft",
+  },
+  {
+    translationKey: "inference",
+    link: "/adrs/llm-training-adr/decisions/inference",
+    date: "May 2026",
+    status: "Draft",
+  },
+];

package/template/app/[lang]/adrs/llm-training-adr/page.tsx

@@ -0,0 +1,38 @@
+import { ADRCategoryPage } from "@/app/[lang]/components/ADRCategoryPage";
+import { LLMTrainingAdrsList } from "./llm-training-adrs-list";
+import { getDictionary } from "@/app/[lang]/components/WithDictionary";
+import type { Locale } from "@/i18n-config";
+
+export default async function Page({
+  params,
+}: {
+  params: Promise<{ lang: Locale }>;
+}) {
+  const { lang } = await params;
+
+  const globalDict = await getDictionary(lang);
+
+  // Load colocated dictionary
+  let decisionDict: Record<string, string> = {};
+  try {
+    const module = await import(`./decisions-dictionaries/${lang}.json`);
+    decisionDict = module.default || module;
+  } catch (err) {
+    console.warn("Could not load colocated decision dictionary");
+  }
+
+  // Merge both into ONE dict (this eliminates all the double-passing)
+  const dict = { ...globalDict, ...decisionDict };
+
+  return (
+    <ADRCategoryPage
+      title={globalDict["llm-training-adr"] ?? "LLM Training ADR"}
+      publishedDate={
+        globalDict["llm-training-adr.published"] ?? "Published April 2026"
+      }
+      description={<></>}
+      adrsList={LLMTrainingAdrsList}
+      dict={dict} // ← single dict now
+    />
+  );
+}

package/template/app/[lang]/adrs/mass-driver-adr/decisions/decision-record-1/page.tsx

@@ -0,0 +1,41 @@
+import { ADRHeader } from '@/app/[lang]/components/ADRHeader';
+import { Link } from '@mui/material';
+import Box from '@mui/material/Box';
+import Typography from '@mui/material/Typography';
+
+export default async function Page() {
+    return(
+        <>
+            <ADRHeader />
+            <Box>
+                {/* <Typography variant="h6" sx={{ marginBottom: 2 }}>
+                    <Link 
+                        href="https://rd-center.vercel.app/nano-assembly/scientific-breakthroughs-for-nano-assembly"
+                        color="inherit"
+                        target="_blank"
+                        sx={{ marginBottom: 2 }}
+                        >
+                        Scientific breakthroughs for Nano-Assembly
+                    </Link>
+                </Typography>
+
+                <Typography variant="h6" sx={{ marginBottom: 2 }}>
+                    2. Advanced Manipulation and Imaging Tools
+                </Typography>
+
+                <Typography sx={{ marginBottom: 2 }}>
+                    Current tools like atomic force microscopes (AFM) can move single atoms, but they're slow 
+                    and limited to surfaces.
+                </Typography>
+
+                <Typography sx={{ marginBottom: 2 }}>
+                    - High-Throughput Nanomanipulation: Create parallel, automated systems for manipulating trillions of atoms simultaneously. Breakthrough: Scalable arrays of nanoscale probes (e.g., enhanced STM or AFM tips) that operate in 3D environments, not just 2D, with feedback loops for real-time correction. This would allow building volumetric structures like rocket tanks.
+                </Typography>
+
+                <Typography sx={{ marginBottom: 2 }}>
+                    - Atomic-Resolution Imaging in Dynamic Environments: Improve imaging to visualize and control reactions in real-time under ambient conditions (not just vacuum or cryo). Breakthrough: Next-gen scanning tunneling microscopy (STM) or electron microscopy with femtosecond resolution, integrated with AI for interpreting noisy data, enabling oversight of nanobot swarms during assembly.
+                </Typography> */}
+            </Box>
+        </>
+    )
+}