Fünf Rust-Projekte zum Lernen – mit Meilensteinen und KI-Schutzmaßnahmen

Rust führt viele Konzepte vorab ein: Eigentumsverhältnisse, Ausleihen, Lebenszeiten, Traits, Fehlerbehandlung, Konkurrenz, Asynchronität sowie ein Ökosystem an Bibliotheken, mit denen man sich auseinandersetzen muss, bevor etwas Nützliches funktioniert. Viele Lernende sammeln daher Tutorials, bleiben aber dennoch vor einem leeren main.rs stecken. Ein zuverlässigerer Ansatz ist es, ein Projekt auszuwählen, das schwierig genug ist, sodass jedes dieser Konzepte zu einem Problem wird, das gelöst werden muss – anstatt nur ein Kapitel, das gelesen wird. Diese Anleitung beschreibt fünf solcher Projekte, was man bei jedem davon lernen kann, wie man eine erste, fertigstellbare Version erstellt und wie man KI-Hilfen nutzen kann, um das Lernen zu beschleunigen, ohne es selbst zu erledigen.

Warum ein schwieriges Projekt besser ist als ein weiterer Kurs

In einem Kurs werden Konzepte in von jemand anderem gewählter Reihenfolge vorgestellt, wobei die Schwierigkeit bereits entfernt ist. Ein echtes Projekt macht das umgekehrt: Man stößt auf Hindernisse, und diese weisen darauf hin, welches Konzept man als Nächstes benötigt. Unterwegs liest man echte Dokumentationen, trifft Architekturentscheidungen, die man später bereut, dekodiert verwirrende Compilerfehler, bemerkt Leistungsprobleme und lernt, wie verschiedene Komponenten zusammenpassen. Das sind die Fähigkeiten, die auf berufliche Tätigkeiten übertragen werden können – und sie lassen sich nicht passiv erlernen.

Die fünf unten aufgeführten Projekte wurden ausgewählt, weil jedes von ihnen gleichzeitig mehrere Aspekte der Sprache berücksichtigt. Wenn Sie ein umfassenderes Verzeichnis an Ideen wünschen, behandelt unser früherer Artikel zu dem Erlernen von Rust durch zehn Projekte ein breiteres Spektrum; hier liegt der Fokus darauf, jedes Projekt so zu gestalten, dass es weiterhin lehrreich bleibt und nicht überwältigend wirkt.

Projekt 1: Ihr eigener Terminal-Code-Agent

AI-Code-Assistenten für die Kommandozeile gehören zu den am aktivsten genutzten Elementen in der Entwicklerwerkzeuglandschaft. Tools wie Claude Code, Codex sowie verschiedene Open-Source-Alternativen ermöglichen es Entwicklern, ein Ziel anzugeben, wodurch ein Agent Dateien durchsucht, Tools aufruft, Code bearbeitet und Berichte erstellt – anstelle dass der Entwickler jeden Befehl manuell eingibt. Eine vereinfachte Version dieses Zyklus eignet sich hervorragend als Übung für Rust, da sie gleichzeitig Netzwerke, Prozesse, das Dateisystem und die Benutzeroberfläche berücksichtigt.

Der Kernzyklus ist einfach aufgebaut: Der Benutzer gibt etwas in eine Terminal-Schnittstelle ein, Ihr Programm leitet das Gespräch an ein Sprachmodell weiter, das Modell kann mit einer Anfrage zur Verwendung eines Tools antworten, Ihr Rust-Code führt dieses Tool aus und das Ergebnis gelangt zurück zum Modell für den nächsten Schritt.

You → Terminal UI → LLM → Tool Request → Your Rust Program → Result → LLM

Der interessante Aspekt ist der Pfeil vom Modell zurück in Ihr Programm. Das Modell berührt Ihren Rechner niemals direkt; es kann nur Anfragen stellen, und Ihr Code entscheidet, ob und wie darauf reagiert werden soll. Genau an dieser Grenze liegt der größte Teil der Entwurfsarbeit.

Eine erste Version, die Sie fertigstellen können

Begonnen wird mit ein paar Werkzeugen und nichts weiter:

• eine Datei öffnen und lesen
• eine Datei erstellen oder überschreiben
• in einem Verzeichnis suchen
• eine Shell-Befehl ausführen
• basisbezogene Projektinformationen anzeigen
• jedes Ergebnis eines Werkzeugs an das Modell zurücksenden

Sobald dieser Schleifenprozess von Anfang bis Ende funktioniert, erweitern Sie ihn schrittweise: speichern Sie den Konversationsverlauf über mehrere Nachrichten hinweg, streamen Sie Antworten, sobald sie eintreffen, fügen Sie Zugriffskontrollen vor zerstörerischen Aktionen hinzu, beschreiben Sie Tools mit präzisen Schemata, unterstützen Sie das Stornieren eines laufenden Schritts und verbessern Sie die Darstellung der Ausgaben im Terminal. Zugriffskontrollen erfordern besondere Sorgfalt. Ein Agent, der willkürliche Befehle auf Ihrem Rechner ausführen kann, sollte vor dem Schreiben außerhalb des Projektverzeichnisses oder der Ausführung von etwas, was er zuvor noch nicht ausgeführt hat, um Erlaubnis fragen.

Was es vermittelt

• async Rust und HTTP-Client für die Kommunikation mit einer Modell-API
• JSON-Serienisierung und -Deserienisierung von Anfragen, Antworten und Toolaufrufen
• Umgang mit gestreamten Antworten
• Auslösen und Verwaltung von Kindprozessen
• Dateisystem-APIs
• Modellierung der Agentenschleife als Zustandsmaschine

Fehlerbehandlung bei Netzwerkproblemen, Parsing-Fehlern und Prozessfehlern

Entwurf der Befehlszeilen- und Terminal-Oberfläche

Nutzung von Tools als Protokoll

Ein weiterer Vorteil ist, dass das Projekt nie wirklich endet. Man kann es monatelang weiter verbessern, was es zu einer guten Langzeit-Testumgebung macht. Wenn Sie wissen möchten, wie derselbe Ablauf aus Sicht von Produkt und Sicherheit aussieht, behandelt unser Artikel über das Erstellen eines persönlichen AI-Agenten mit erworbenem Zugriff die Aspekte des Vertrauens ausführlicher.

Entscheiden Sie, was Sie optimieren möchten

Vor dem Schreiben jeglichen Codes sollte man ehrlich zu seinem Ziel sein. Das Erlernen von Rust, das Erstellen eines Portfolio-Projekts, die Entwicklung einer täglich genutzten Tool, Experimente mit KI oder die Vorbereitung auf eine Position im Bereich Systementwicklung führen alle zu unterschiedlichen Entscheidungen. Ein Portfolio-Projekt belohnt Perfektion; ein täglich genutztes Tool Belastbarkeit; ein Lernprojekt die Anstrengungen, die dabei aufgewendet werden.

Falls das Lernen im Vordergrund steht, sollte man dagegen ankämpfen, dass ein Assistent den gesamten Codebase erstellt. Das Weglassen der frustrierenden Teile bedeutet auch, einen Großteil des Verständnisses zu verlieren, das diese Teile sonst ermöglicht hätten. Es ist in Ordnung, einen Assistenten zu bitten, einen Fehler im Borrow-Checker zu erklären oder einen verwirrenden Abschnitt in der Dokumentation zu klären. Das Delegieren des Designs, bevor man das System verstanden hat, hingegen nicht. Ein Projekt, das drei Tage zum Verstehen braucht, lehrt in der Regel viel mehr als eines, das in drei Stunden erstellt wird.

Projekt 2: Eine Desktop-App mit Tauri

Rust ist bekannt für Server, Kommandozeilenwerkzeuge und Code auf niedrigem Niveau, doch es eignet sich auch hervorragend für Desktop-Software. Tauri kombiniert eine webbasierte Benutzeroberfläche mit einem Rust-Backend, sodass Sie eine Anwendung erstellen können, die wie moderne Desktop-Software aussieht und sich anfühlt, während die wichtige Logik in Rust ausgeführt wird. Falls Sie zunächst Tauri mit anderen Optionen vergleichen möchten, zeigt unser Vergleich der JavaScript-Desktop-Frameworks die Vor- und Nachteile auf.

Vermeiden Sie die allgemeinen To-Do-Listen und entwickeln Sie etwas, das Sie tatsächlich jeden Tag öffnen würden. Eine konkrete Idee ist ein lokaler Produktivitätsassistent, der Audio aufnimmt, Sprache in Text transkribiert, Notizen auf Ihrer eigenen Festplatte speichert und ausgewählten Text wieder für Sie vorliest. Weitere gute Optionen sind ein persönlicher Dateiorganisator, eine Markdown-Arbeitsumgebung, ein Entwickler-Dashboard, ein Medien-Tool oder ein lokales KI-Tool.

Die Idee selbst ist weniger wichtig als die Verbindung zwischen der Web-Oberfläche und dem nativen Backend. Jeder Button in der Benutzeroberfläche wird letztendlich zu einem Aufruf über diese Grenze, und das gute Design dieser Oberfläche ist die eigentliche Lektion. Ein sinnvoller erster Meilenstein ist ein Befehl, der aus Rust bereitgestellt wird und vom Frontend aufgerufen wird, um etwas zu erledigen, was der Browser allein nicht kann – beispielsweise die Anzeige einer Ordnerliste.

Was es lehrt

• Die Strukturierung einer Rust-Anwendung mit mehr als einer Schicht

Kommunikation zwischen der Frontend-Schicht und Rust

Paketierung und Verbreitung von Desktop-Anwendungen

Lokaler Speicher

Threads und Hintergrundaufgaben, die eine reaktive Benutzeroberfläche gewährleisten

Dateisystemoperationen

Aufruf externer APIs und Dienste

Zustandsverwaltung

Fehlerbehandlung, die nützliche Nachrichten in der Benutzeroberfläche anzeigt

Sicherheitsaspekte für eine native Anwendung, die Webinhalte darstellt

Die übergeordnete Lektion ist, dass Software erheblich schwieriger wird, sobald sie mit einem echten Betriebssystem in Berührung kommt. Ein Datei lesen erfordert nur eine Zeile Code. Sicher mit Dateien umzugehen, Fehler klar zu melden, auch bei langsamen Aufgaben reaktiv zu bleiben und auf verschiedenen Maschinen gleich zu funktionieren, ist ein völlig anderes Problem – und genau diese Herausforderung lohnt sich.

Projekt 3: Ein Tower-Defense-Spiel in Bevy

Ein Spiel ist eines der wenigen Projekte, die es ermöglichen, zu vergessen, dass man lernt. Es ist außerdem ein fordernder „Lehrer“, denn in jedem Frame müssen viele Systeme gleichzeitig laufen: Entitäten, Spielereingaben, Physik, Rendering, Zeitsteuerung, Übergänge zwischen Zuständen sowie das Leistungsbudget, das alles zusammenhält.

Bevy eignet sich hervorragend für Rust-Lerner, da es auf einem Entity Component System (ECS) basiert. Anstelle großer Objekte, die alle Verhaltensweisen in sich bündeln, ist eine Entity im Grunde nur ein Identifikator mit angehängten Komponenten, und Systeme sind Funktionen, die auf jeder Entity mit einer bestimmten Komponentensammlung ausgeführt werden. Ein Projektil kann beispielsweise eine Position, eine Geschwindigkeit und einen Schadenswert haben; ein Bewegungssystem aktualisiert alles, was mit Position und Geschwindigkeit zu tun hat, während ein Kollisionsystem alles handhabt, was Schaden verursacht. Dieser Wandel von Objekten zu Daten in Kombination mit Funktionen ist eines der wertvollsten Denkmuster, die Rust und Bevy Ihnen vermitteln können.

Warum gerade Tower Defense?

Dieses Genre führt schnell zu einer großen Anzahl an Entities, was genau das Ausbildende daran ausmacht. Eine einzige Karte kann Folgendes umfassen:

• Hunderte Feinde gleichzeitig
• Mehrere Türme mit unterschiedlichen Verhaltensweisen

Fliegende Projektile

Gesundheit- und Schadenssysteme

Pfadfindung

Angriffswellen

Aktualisierungen

Mehrere Feindertypen

In diesem Maßstab ist Korrektheit nicht mehr die einzige Frage. Man beginnt, sich zu fragen, wie viel Rechenleistung das Spiel in jedem Frame benötigt. Diese Frage führt zwangsläufig zu Profilierung, Datenstruktur, Systemplanung, Speichernutzung sowie zur Auswahl von Algorithmen, die bei steigenden Zahlen nicht zusammenbrechen. Ein guter erster Meilenstein ist ein einziger Feind, der einen festen Pfad entlanggeht, und eine einzige Turm, die auf ihn schießt; alles Weitere kann hinzugefügt werden, sobald dieser Kreislauf stabil ist.

Was es lehrt

• Wie ein Entity Component System strukturiert ist
• Der Spielzyklus und die Frame-Zeitierung
• Reaktion auf Ereignisse
• Verwaltung des Zustands über Menüs, Level und Spielende hinweg
• Leistungsprofilierung
• datenorientiertes Design
• Ressourcenverwaltung
• Grundlagen der Darstellung
• Eingabeverarbeitung
• Optimierung

Spiele lehren außerdem etwas, was Tutorials nur selten schaffen: wie mehrere unabhängige Systeme miteinander interagieren, sobald das Programm wirklich komplex wird, und wie kleine Veränderungen in einem System Auswirkungen auf andere hat.

Projekt 4: Ein eingebettetes Gerät mit lokaler ML-Verarbeitung

Beschränkter Hardware macht Rust noch interessanter: knappe Speichermengen, begrenztes Energiebudget und eingeschränkte CPU-Zeit. Anstatt auf einen Laptop abzustellen, sollte man sich auf Mikrocontroller oder kleine Edge-Geräte konzentrieren.

Ein praktisches Beispiel ist ein Gerät, das seine Umgebung überwacht und auf Veränderungen reagiert. Es könnte folgende Werte messen:

• Temperatur
• Feuchtigkeit
• Lichtstärke
• Bewegung
• Klang
• Weitere Sensordaten

Zusätzlich kann man ein kompaktes Machine-Learning-Modell für eine bestimmte Aufgabe hinzufügen: das Erkennen von Anomalien, das Identifizieren von Gesten oder das Abhören eines Aktivierungsworts. Halten Sie den Modulteil bescheiden; das eigentliche Lernen besteht darin, alles auf begrenzten Hardware-Ressourcen zu betreiben.

Man benötigt keine teure Hardware, um anzufangen. Ein Emulator oder Simulator reicht aus, um die Architektur sowie die Programmiertechniken zu erlernen, und man kann auf eine physische Platine wechseln, sobald die Software funktioniert.

Warum Embedded Rust sich anders anfühlt

Eine Desktop-Anwendung verfügt über eine vollständige Standardbibliothek, viel Speicher, einen schnellen CPU und ein Betriebssystem, das unzählige untere Ebene-Details übernimmt. Bei der Embedded-Entwicklung wird vieles davon weggelassen, was zu einer neuen Reihe von Themen führt:

• no_std-Rust, bei dem die Standardbibliothek nicht verfügbar ist
• Arbeiten innerhalb enger Speichergrenzen
• Hardware-Interfaces

Störungen

Verhalten in Echtzeit

Gerätedriver

Kommunikation mit Peripheriegeräten

Cross-Compilation

Die Tools und das Ökosystem rund um bestimmte Mikrocontroller

Das ist eine der klarsten Beispiele dafür, warum Rust für mehr als nur gewöhnliche Anwendungen wichtig ist. Man muss verstehen, was die Maschine tatsächlich tut, denn es gibt nichts, das dies verbergen könnte. Die Arbeit im Bereich Embedded-Systeme verbindet außerdem Rust mit Robotik, Automobilsystemen, Industrieanlagen und anderen hardwareintensiven Bereichen.

Projekt 5: ein adaptiver Lastausgleicher

Für Backend-Entwickler erweitert eine weitere CRUD-API in der Regel ihre Fähigkeiten nur wenig. Der Aufbau eigener Infrastruktur hingegen schon. Ein Load Balancer eignet sich hier gut: Er befindet sich zwischen Clients und einer Gruppe von Backend-Servern und entscheidet für jede eingehende Anfrage, welcher Server sie bearbeiten soll, anstatt den gesamten Verkehr an einen einzigen Rechner zu leiten.

Die Grundstruktur ist einfach: Clients verbinden sich mit Ihrem Rust-Prozess, und dieser leitet jede Anfrage an einen der mehreren Server weiter.

┌─────────────┐
                │   Clients   │
                └──────┬──────┘
                       │
                       ▼
              ┌─────────────────┐
              │  Rust Load      │
              │    Balancer     │
              └───────┬─────────┘
                  ┌───┴───┐
                  ▼       ▼
             ┌────────┐ ┌────────┐
             │Worker 1│ │Worker 2│
             └────────┘ └────────┘

Meilensteine vom naiven zum adaptiven Ansatz

Fangen Sie mit einer einfachen Round-Robin-Verteilung an, bei der jede Anfrage nacheinander an den nächsten Server weitergeleitet wird. Damit lässt sich leicht arbeiten und Sie erhalten eine Grundlage. Fügen Sie anschließend schrittweise Intelligenz hinzu:

• messen Sie die Antwortzeiten und Fehlerraten pro Server
• erkennen Sie fehlerhafte Server und stoppen Sie die Weiterleitung an sie
• setzen Sie Verbindungslimits durch

Probieren Sie alternative Routing-Strategien aus und vergleichen Sie sie unter Last.

Irgendwann kann der Balancer sein Verhalten an die tatsächlichen Verkehrsbedingungen anpassen, anstatt einer festen Regel zu folgen.

Wo es schwierig wird

Stellen Sie sich vor, ein Worker verlangsamt sich plötzlich. Sollten neue Anfragen weiterhin dorthin gesendet werden? Fast sicher nicht. Noch schwieriger ist es, wenn mehrere Worker gleichzeitig ihre Leistung verschlechtern – jeder aus unterschiedlichen Gründen: Einer ist überlastet, ein anderer hat ein instabiles Netzwerkverbindung, wieder ein anderer führt eine Garbage-Collection-Aktion durch. Ihr System muss beobachten, was vor sich geht, und schnell Entscheidungen treffen, ohne selbst zum Engpass zu werden. Dazu gehören:

• Konkurrenzverarbeitung
• Grundlagen des Netzwerkens
• TCP und HTTP
• Rückwärts-Proxying
• Gesundheitsprüfungen und Zeitlimits
• Pooling von Verbindungen zu Workers
• Sammlung von Metriken
• Gerechte Lastverteilung
• Rückdruck, wenn alle Worker beschäftigt sind
• Umgang mit Fehlern auf elegante Weise
• Denken in distribuierten Systemen

Man könnte mit einer von KI unterstützten Routing-Strategie experimentieren, sollte dies aber streng als Experiment betrachten. Kritische Infrastrukturen dürfen niemals blind auf die Entscheidungen eines Modells vertrauen, und es muss stets eine deterministische Alternative vorhanden sein. KI allein bringt nichts hinzu; das Ziel ist es zu prüfen, ob sie das System tatsächlich im Vergleich zu einer einfachen, gut verstandenen Strategie verbessert.

Was diese Projekte gemeinsam haben

Der gemeinsame Bestandteil ist nicht die Syntax. Es ist die Komplexität, der man nicht ausweichen kann.

Ein Tutorial kann zeigen, wie Arc<Mutex<T>> funktioniert; ein Projekt lässt einen erkennen, warum gemeinsamer Zustand überhaupt synchronisiert werden muss – meistens nachdem der Compiler es verweigert, ihn unsicher zu teilen. Asynchrone Funktionen sind auf dem Papier leicht zu erklären; eine echte Anwendung zeigt, was passiert, wenn mehrere Aufgaben miteinander interagieren, eine Anfrage auf halbem Weg storniert wird oder die Netzwerkverbindung abbricht. Ein Buch kann das Konzept des Eigentums erläutern; ein Projekt zwingt einen dazu, Strukturen zu entwerfen, bei denen jeder Ressource der richtige Eigentümer zugeordnet ist und sie zur richtigen Zeit freigegeben wird. Dieser Unterschied macht den Unterschied zwischen dem Kennen einer Sprache und dem Wissen, wie man mit ihr Software entwickelt.

Wählen Sie ein Projekt, das etwas schwierig ist

Eine nützliche Auswahlregel: Wählen Sie etwas, das gerade außerhalb Ihrer aktuellen Fähigkeiten liegt. Es sollte nicht unmöglich sein und auch nichts sein, was Sie bereits können. Das richtige Projekt bringt Sie dazu, immer wieder zu erkennen, dass Sie noch keine Ahnung haben, wie ein bestimmter Teil davon funktioniert.

Dieses Gefühl ist ein gutes Zeichen. Rechnen Sie damit, viel Dokumentation lesen zu müssen, Ihren Code kaputtzumachen, APIs falsch zu interpretieren, eine Abstraktion zu schreiben, die sich als schlecht erweist und später ersetzt werden muss, sowie öfter mit dem Compiler zu hadern. Nach einigen Tagen wird dann etwas, das unmöglich schien, plötzlich verständlich. Diese Erfahrung lässt sich kaum durch das Anschauen eines weiteren Tutorials nachahmen.

KI nutzen, ohne das Lernen auszulagern

Die Art und Weise, wie Sie KI-Hilfe nutzen, kann mehr als jeder andere Faktor beeinflussen, wie viel ein Projekt Ihnen beibringt. Moderne Assistenten sind tatsächlich nützlich: Sie klären Fehlermeldungen auf, kürzen lange Dokumentationen ab, schlagen Ansätze vor und helfen Ihnen dabei, in Bugs einzudringen. Entscheidend ist hier der Unterschied zwischen der Nutzung der KI als Werkzeug und ihrer Verwendung als Ersatz für das eigene Verständnis.

Bei einem auf Lernen ausgerichteten Projekt sieht eine praktikable Disziplin so aus:

• Schreiben Sie die erste Version selbst.
• Lesen Sie die relevanten Dokumentationen, bevor Sie um Hilfe bitten.
• Probieren Sie jedes Problem selbst aus, bevor Sie nach einer Lösung fragen.
• Falls Sie feststecken, bitten Sie um eine Erklärung statt um fertigen Code.
• Implementieren Sie die Korrektur selbst, auch wenn Sie nun wissen, wie sie aussehen sollte.
• Sichern Sie sich zu, dass Sie jeden wichtigen Teil des Systems ohne Nachschlagen erklären können.

Das bedeutet nicht, KI zu vermeiden. Es bedeutet vielmehr, sicherzustellen, dass Sie weiterhin derjenige sind, der denkt.

Einen Projekttyp an Ihr Ziel anpassen

Lassen Sie den Typ des Ingenieurs, der Sie werden möchten, die Entscheidung leiten:

• KI und Entwicklerwerkzeuge: Erstellen Sie einen Terminal-Code-Agenten
• Desktop-Software: Erstellen Sie eine Tauri-Anwendung
• Spiele und Leistung: Erstellen Sie das Bevy-Turmverteidigungsspiel
• Robotik, Hardware oder Arbeit auf niedriger Ebene: Erstellen Sie ein eingebettetes Gerät
• Backend-Infrastruktur und verteilte Systeme: den adaptiven Lastausgleicher

Egal, was Sie wählen – streben Sie keine Perfektion an. Bringen Sie zunächst die kleinste funktionsfähige Version zum Laufen und arbeiten Sie anschließend daran weiter.

Kernpunkte

• Wählen Sie Projekte, deren Schwierigkeit Sie dazu zwingt, Verantwortung zu übernehmen, Konkurrenzverhältnisse zu handhaben, asynchrone Abläufe zu gestalten und Fehler zu bewältigen – anstatt nur abstrakt darüber zu lesen.
• Definieren Sie für jedes Projekt ein kleines erstes Meilenstein und erweitern Sie es schrittweise; ein funktionsfähiger kleiner Schleifencode bringt mehr bei als ein ehrgeiziges Design, das nie läuft.
• Entscheiden Sie im Voraus, ob Sie lernen, ein Portfolio-Projekt erstellen oder ein Tool veröffentlichen möchten – denn jedes Ziel rechtfertigt andere Abkürzungen.
• Nutzen Sie KI zur Erklärung, nicht zur Erstellung von Code, da das Lernen das Ziel ist, und behalten Sie deterministische Rückfalle bei allen Fällen, in denen ein Modell in einem echten System Entscheidungen trifft.
• Der Kreislauf aus Erstellen, Zerstören, Untersuchen, Neugestalten und Optimieren ist die Quelle des größten Verständnisses für Rust – bereits ein Wochenende damit kann mehr bringen als viele Stunden an passiven Tutorien.