Nvidia gibt MotionBricks frei: KI erzeugt Bewegungen für Spielfiguren und Roboter

Nvidia hat Code und Modelle von MotionBricks kostenlos veröffentlicht. Die KI erzeugt in Echtzeit die Bewegungen von Spielfiguren und dem humanoiden Roboter Unitree G1, ohne dass Animatoren die Übergänge von Hand bauen müssen. Ein fertiges Produkt ist es noch nicht, und die guten Zahlen stammen bisher nur von den Entwicklern selbst.

Forschung Selbst ausprobieren 9. Nov. 2026 8 Min. Lesezeit Quelle: Bing News (pt-BR)
Symbolbild, KI-generiert

Worum es geht

Nvidia hat MotionBricks veröffentlicht, also Programmcode und vortrainierte Modelle. Die KI erzeugt in Echtzeit, wie sich eine Spielfigur oder der humanoide Roboter Unitree G1 bewegt. Dafür braucht sie nur wenige Zielposen, etwa „Figur sitzt auf der Bank“ oder „Figur hält das Schwert“. Den Weg dorthin rechnet das Modell selbst aus. In heutigen Spielen bauen Animatoren genau diese Übergänge mühsam von Hand. Laut der offiziellen Projektseite deckt ein einziges Modell mehr als 350.000 Bewegungen ab. Es soll 15.000 Bilder pro Sekunde schaffen, bei einer Latenz (Verzögerung) von 2 Millisekunden.

Entwickelt hat es das GEAR-Labor von Nvidia Research, zusammen mit Forschenden der ETH Zürich, der Simon Fraser University und der University of Texas at Austin. Hinter dem Fachartikel stehen 16 Forschende unter der Leitung von Tingwu Wang und Olivier Dionne. Er erschien in der Fachzeitschrift ACM Transactions on Graphics und wurde im Juli auf der Grafikkonferenz SIGGRAPH 2026 vorgestellt. Den Vorabdruck gibt es seit dem 27. April auf arXiv. Alles ist kostenlos und offen, aber es ist Forschung und kein fertiges Produkt.

Das Problem: Animation ist teuer

Eine Spielfigur soll gehen, rennen, sich ducken, über Hindernisse springen und sich hinsetzen können. Dafür nehmen Studios heute Hunderte Clips per Motion Capture auf, also mit Schauspielern in Spezialanzügen, deren Bewegungen digital erfasst werden. Diese Clips verbinden sie in einer Zustandsmaschine. Das ist eine Art riesiges Schaltbild, das festlegt, welche Animation auf welche folgen darf. Jedes neue Verhalten macht das Schaltbild größer und teurer.

Wie groß solche Systeme werden, zeigt der Artikel am Beispiel Assassin's Creed. Dessen Animationsgraph kann mehr als 15.000 Animationen und 5.000 Zustände umfassen, verschachtelt in bis zu 12 Ebenen. Heute setzt die Branche oft auf Motion Matching. Dabei sucht das Spiel in einer Datenbank den passenden schon aufgenommenen Bewegungsschnipsel heraus. Unreal Engine 5 bringt das Verfahren mit, dazu eine kostenlose Beispielsammlung von Epic mit mehr als 500 Animationen. MotionBricks sucht dagegen nicht, es erzeugt Bewegung neu. Dazu gehören auch Übergänge, die nie jemand aufgenommen hat.

So erzeugt MotionBricks Bewegung

Die Kerntechnik heißt In-Betweening: Das Modell füllt die Lücke zwischen Schlüsselposen, ähnlich wie früher Zeichner die Zwischenbilder eines Trickfilms. Dreißigmal pro Sekunde bekommt es zwei Eingaben. Die erste ist der Kontext, also die vier letzten Posen der Figur mit Haltung und Geschwindigkeit. Die zweite sind ein bis vier Zielposen, die die Bewegung erreichen soll. Gibt man mehrere Ziele vor, versteht das System auch Tempo und Schwung. Die Figur läuft dann durch einen Punkt hindurch, statt dort abzubremsen.

Wie lange ein Übergang dauert, entscheidet das Modell selbst. Jeder Durchgang erzeugt 0,6 bis 1,9 Sekunden Bewegung. Das läuft in drei Schritten ab:

  • Ein Modul sagt die Dauer und den Weg des Beckens voraus.
  • Ein Transformer füllt entlang dieses Wegs die eigentliche Bewegung aus. Das ist die Netzarchitektur, die auch hinter Sprachmodellen steckt.
  • Ein VQ-VAE-Decoder macht daraus eine flüssige Animation, bei der die Füße sauber auf dem Boden bleiben. Ein VQ-VAE speichert Bewegungen als eine Art Baukasten aus festen Bausteinen.

Längere Bewegungen entstehen, indem mehrere Durchgänge aneinandergehängt werden. Ändert der Spieler die Richtung, plant das Modell neu.

Trainiert wurde mit BONES-SEED, einem Datensatz von 350.000 Motion-Capture-Clips mit echten Schauspielern. Die Bones Studio hat ihn aufgenommen und auf Hugging Face veröffentlicht. Darauf aufbauend hat Nvidia sogenannte Smart Primitives gebaut, wiederverwendbare Bewegungsbausteine. Bei der Fortbewegung werden Befehle für Tempo, Richtung und Stil zu Zielposen. So wechselt die Figur ohne neues Training zwischen Zombie-Gang, Humpeln, Seitwärtslaufen und geducktem Rennen. Bei Objekten reichen wenige Schlüsselposen:

„Das Modell füllt die Annäherung, den Kontakt und den Abschluss aus“, heißt es auf der Projektseite.

Dazu gehören etwa ein Schwert greifen, über eine Bank springen oder sich hinsetzen. Laut Artikel baut eine Person ohne Animationsausbildung so einen Baustein in Unreal Engine 5 in weniger als zehn Minuten.

Die Zahlen und ihr Kleingedrucktes

Die offizielle Demo zeigt 2 Minuten und 40 Sekunden am Stück in Unreal Engine 5. Die Figur bewegt sich durch die Umgebung und interagiert mit ihr. Nvidia schreibt dazu:

„Jede Bewegung wird von neuronalen Netzen erzeugt: kein Foot-Locking, kein Blending, keine Kollisionserkennung, keine handgemachten Übergänge.“

Die Ergebnisse aus dem Fachartikel wurden an rund 35.000 Clips gegen sechs Konkurrenzverfahren gemessen. Das Portal i-scoop hat sie zusammengestellt:

Test MotionBricks Vergleich
Erreicht Zielpose (bis 5 cm und 15°) 99,6 % 87,7 % beim besten Konkurrenten, höchstens 78,2 % bei Diffusionsmodellen
Bevorzugt von 40 Fachleuten aus Animation und Robotik 86,5 % der Vergleiche jeweils gegen zwei Verfahren
Roboter-Benchmark LaFAN1-G1 61,1 % Trefferquote der Zielpose
Geschwindigkeit 15.000 FPS, 2 ms gemessen auf RTX 5090
Modellgröße ca. 200 Mio. Parameter Checkpoints öffentlich

Alle Werte stammen von den Autoren selbst. Unabhängig nachgeprüft hat sie bisher niemand. Die 99,6 Prozent beziehen sich zudem auf einen firmeneigenen Datensatz der Bones Studio mit rund 700 Stunden Aufnahmen, 9.300 Fähigkeiten und 163 Schauspielern. Auf den öffentlichen Datensätzen HumanML3D und LaFAN1 wird der Vorsprung kleiner. Bei der Vielfalt der Bewegungen liegen manche Verfahren gleichauf oder sogar vorn. Im Robotertest sinkt die Trefferquote auf 61,1 Prozent. Und die 15.000 Bilder pro Sekunde wurden auf einer RTX 5090 gemessen, der stärksten Karte der Reihe. Die veröffentlichten Demos hat Nvidia auf einer RTX 4090 getestet. Laut i-scoop nutzt bisher kein kommerzielles Spiel die Technik.

Dasselbe Modell bewegt einen Roboter

Nvidia hat außerdem eine Version für den humanoiden Roboter Unitree G1 trainiert. Die Bewegungsdaten wurden dafür auf das Skelett des Roboters übertragen. Die Eingabe funktioniert genauso wie bei der Spielfigur, ebenfalls über Zielposen. Auf dem Jetson Orin, dem eingebauten Rechner des G1, dauert ein Durchgang 5 Millisekunden. Das Modell plant zehnmal pro Sekunde neu oder bei jedem neuen Befehl. Laut Projektseite ist MotionBricks bereits ein zentraler Teil von GR00T Whole-Body Control, Nvidias Software zur Steuerung humanoider Roboter. Dort arbeitet es zusammen mit GEAR-SONIC.

Eine Grenze gibt es aber: Das Modell gibt gewünschte Posen aus, keine Befehle für die Motoren. Damit der Roboter nicht umfällt, sorgt ein eigener Regler, der den Posen folgt. Die Modellkarten warnen ausdrücklich, die erzeugte Bewegung sei „nicht für die physische Robotersteuerung validiert“. MotionBricks ist hier also ein Bewegungsplaner.

Download, Lizenzen und was fehlt

Alles liegt kostenlos im GitHub-Repository NVlabs/motionbricks. Darin stecken:

  • eine Python-Laufzeitumgebung (mit Warp, Newton und TensorRT)
  • vortrainierte Modelle für das menschliche Skelett SOMA und für den G1 im Format ONNX, einem Austauschformat für KI-Modelle, das viele Programme lesen können
  • Checkpoints auf Hugging Face
  • zwei Demos (Inbetweener und Scene Preview)
  • zwei Editoren, einer zum Bauen von Bewegungsbausteinen und einer zum Zusammenstellen von Szenen

Laut i-scoop fehlen das Unreal-Plugin aus der Demo, die vollständige Trainings-Pipeline und die kompletten Trainingsdaten. Eine offizielle Anbindung an Unity oder Godot gibt es nicht. Wegen des ONNX-Formats kann ein Studio sie selbst bauen, muss die Arbeit dann aber auch selbst machen.

Bei den Lizenzen gibt es drei Stufen:

  • Der Code steht unter Apache 2.0, kommerzielle Nutzung ist frei.
  • Die trainierten Modelle stehen unter dem NVIDIA Open Model Agreement. Es erlaubt kommerzielle Nutzung, die Lizenz erlischt aber, wenn man Nvidia verklagt und behauptet, das Modell verletze ein Patent oder Urheberrecht.
  • Die Beispielbewegungen stehen unter einer reinen Evaluationslizenz. Sie dürfen nicht in einem veröffentlichten Spiel landen.

Was du zum Ausprobieren brauchst

Du brauchst eine Nvidia-Grafikkarte. Andere Hersteller und Apple-Macs werden nicht unterstützt. Nvidia dokumentiert Tests nur unter Windows und Linux mit einer RTX 4090. Wie gut es auf günstigeren RTX-Karten läuft, sagt Nvidia nicht. Das Modell ist mit rund 200 Millionen Parametern klein und dürfte rechnerisch wenig Grafikspeicher brauchen. Garantiert ist das aber nicht. Außerdem solltest du dich mit Python auskennen. Eine Ein-Klick-App wie bei Chatbots gibt es nicht.

Einordnung

MotionBricks greift ein echtes, teures Problem der Spieleentwicklung an. Statt riesiger Schaltbilder aus Tausenden Clips braucht es nur ein Modell und ein paar Zielposen. Interessant ist das vor allem für kleine Studios ohne eigenes Animationsteam. Dass dasselbe Modell auch einen Roboter bewegt, zeigt, wie eng Nvidia Spiele und Robotik verbindet.

In der Praxis bleiben aber Hürden. Die Spitzenwerte beruhen auf firmeneigenen Daten und wurden nicht unabhängig geprüft. Auf öffentlichen Datensätzen und beim Roboter schrumpft der Vorsprung deutlich. Das Plugin für die Spiel-Engine fehlt. Und das Modell kann nur, was in seinen Trainingsdaten steckt. Der Engpass verschiebt sich damit: Wer es in einem Spiel einsetzen will, braucht lizenzierte Bewegungsdaten, um es zu trainieren oder anzupassen. Bis zum ersten Spiel, das MotionBricks nutzt, ist es also noch ein Stück.

Quellen

#nvidia#animation#robotik#gaming#open source#siggraph
Originalquelle lesen

Selbst ausprobieren: MotionBricks

Schritt für Schritt erklärt, auch ohne Vorkenntnisse – auf deinem Rechner oder kostenlos im Browser.

Was kann ich damit machen?

MotionBricks erzeugt Bewegungen für ein menschliches 3D-Skelett (SOMA) oder für den Roboter Unitree G1. Du gibst ein bis vier Zielposen vor, und das Modell rechnet in Echtzeit eine flüssige, natürliche Bewegung dorthin aus, mit Füßen, die sauber am Boden bleiben. Über Befehle für Tempo, Richtung und Stil wechselt die Figur zum Beispiel zwischen Gehen, Humpeln, Zombie-Gang oder geducktem Rennen. Interaktionen wie Hinsetzen, über eine Bank springen oder ein Schwert greifen lassen sich als Bausteine mit wenigen Schlüsselposen definieren. Das Modell ist mit rund 200 Millionen Parametern klein und laut Nvidia extrem schnell. Es kann aber nur, was in seinen Trainingsdaten steckt, und auf öffentlichen Datensätzen ist der Vorsprung vor anderen Verfahren deutlich kleiner als auf Nvidias eigenem. Ein Chatbot ist es nicht: Man tippt keine Texte ein, sondern arbeitet mit Posen, Demos und Editoren. Für echte Robotermotoren ist die Ausgabe ausdrücklich nicht validiert.

Für wen lohnt es sich?

Lohnend ist es für Spieleentwickler, Technical Artists, Robotik-Bastler und Studierende mit Python-Kenntnissen und einer starken Nvidia-Karte. Wer einfach nur KI ausprobieren will, ohne Mac- oder AMD-Karte und ohne Programmiererfahrung, wird damit kaum glücklich, denn es gibt keine fertige App und kein Unreal-Plugin.

Ideen: Was du damit anstellen kannst

Prototyp für ein Indie-Spiel

Du nutzt MotionBricks, um einer Testfigur schnell Laufen, Ducken und Springen zu geben, ohne Hunderte Clips zu verdrahten. So siehst du früh, ob sich die Steuerung gut anfühlt, bevor du in echte Animationen investierst.

Previsualisierung für Filmszenen

Im Szenen-Editor stellst du Figuren, Bänke und Objekte grob zusammen und lässt die Bewegungen automatisch erzeugen. So entsteht ein schnelles Storyboard in 3D, mit dem man über Kamera und Abläufe sprechen kann.

Eigene Bewegungsbausteine bauen

Mit dem Primitive-Editor legst du Bausteine wie „Tür öffnen“ oder „auf Kiste steigen“ aus wenigen Posen an. Laut Nvidia schafft das auch jemand ohne Animationsausbildung in unter zehn Minuten.

Robotik-Forschung mit dem Unitree G1

Mit dem G1-Modell planst du Bewegungen für den humanoiden Roboter in Simulation und kombinierst sie mit einem eigenen Regler. Das ist ein guter Einstieg in Nvidias Robotersteuerung GR00T Whole-Body Control.

Lernen und Lehren

Studierende können an den Demos nachvollziehen, wie In-Betweening mit Transformer und VQ-VAE funktioniert. Der offene Code eignet sich für Seminare zu Animation und Robotik.

Größe0,2 Mrd. Parameter
Download1,6 GB (bei 100 MBit/s ca. 2 Min.)
LizenzCode: Apache 2.0; Modelle: NVIDIA Open Model Agreement
ArtKI-Modell

Was dein Rechner braucht

Grafikkarte (NVIDIA) mind. 2 GB VRAMDie Zahl ist berechnet, nicht vom Hersteller angegeben. Eine Modellfamilie (z. B. SOMA) hat zusammen etwa 0,8 GB Gewichte in fp32. Das ergibt × 1,2 + 1 GB, also rund 2 GB. NVIDIA hat nur auf einer RTX 4090 mit 24 GB getestet. Mehr Grafikspeicher bringt bei diesem kleinen Modell kaum Vorteile. Eine NVIDIA-Grafikkarte ist aber Pflicht, weil TensorRT nur darauf läuft.
Mac (Apple Silicon M1–M5) nicht unterstütztDas Programm nutzt TensorRT und braucht laut NVIDIA zwingend eine NVIDIA-Grafikkarte. Macs haben so eine Karte nicht. Nimm stattdessen einen Windows- oder Linux-PC mit NVIDIA-Karte oder schau dir die Videos auf der Projektseite an.
Speicherplatz ca. 3,6 GB freiModell-Download plus Programme

Es gibt zwei vortrainierte Modelle im ONNX-Format: eines für das menschliche Skelett SOMA (für Spielfiguren und Animation) und eines für den Roboter Unitree G1. Für Spiele und Animation nimmst du das SOMA-Modell, das G1-Modell nur, wenn du mit dem Roboter oder dessen Simulation arbeitest. Quantisierte Varianten gibt es nicht. Offiziell getestet ist nur eine RTX 4090.

  • Eine Nvidia-Grafikkarte ist Pflicht, denn die Laufzeitumgebung nutzt Warp, Newton und TensorRT. AMD, Intel-Grafik und Apple Silicon werden nicht unterstützt.
  • Nvidia dokumentiert Tests nur unter Windows und Linux mit einer RTX 4090.
  • Die 15.000 Bilder pro Sekunde und 2 ms Latenz wurden auf einer RTX 5090 gemessen. Für schwächere RTX-Karten gibt es keine Angaben.
  • Das Modell hat nur rund 200 Millionen Parameter und dürfte daher wenig Grafikspeicher brauchen. Offiziell bestätigt ist das nicht.
  • Auf dem Jetson Orin im Unitree G1 braucht ein Durchgang laut Nvidia 5 Millisekunden.
  • Ein reiner CPU-Betrieb ist nicht vorgesehen.
Wie finde ich heraus, was mein Rechner hat?
  • Windows: Strg + Umschalt + Esc drücken → Task-Manager → Reiter Leistung → links GPU anklicken. Unten steht Dedizierter GPU-Speicher (das ist dein VRAM). Den Arbeitsspeicher findest du unter Arbeitsspeicher.
  • Mac: Apfel-Menü oben links → Über diesen Mac. Dort stehen Chip (z. B. M2) und Speicher (z. B. 16 GB). Bei Apple-Chips teilen sich Grafik und Prozessor diesen Speicher.
  • Linux: Im Terminal nvidia-smi eingeben (zeigt Grafikkarte und Speicher) und free -h für den Arbeitsspeicher.

Anleitung

Dieses Modell läuft mit einem eigenen Programm seiner Entwickler (NVlabs/motionbricks auf GitHub). Die Befehle unten stammen aus der Model Card und der Anleitung der Entwickler.

Windows 10 / 11

Windows 10 / 11: unterstützt. NVIDIA hat Windows offiziell mit einer RTX 4090 getestet. Du brauchst eine NVIDIA-Grafikkarte, denn das Programm nutzt TensorRT (NVIDIAs Beschleuniger-Software).

  1. Voraussetzungen installieren. Du brauchst eine NVIDIA-Grafikkarte mit aktuellem Treiber. Installiere Git, Git LFS (eine Git-Erweiterung für große Dateien) und uv (ein schneller Python-Paketmanager, der auch Python selbst mitbringt). Die Installationsprogramme findest du auf den offiziellen Websites der Projekte. Ob alles da ist, prüfst du in PowerShell mit den Befehlen hier: Jeder sollte eine Versionsnummer ausgeben.
    nvidia-smi
    git --version
    git lfs version
    uv --version
  2. Git LFS einrichten. Dieser Befehl aktiviert Git LFS einmalig für deinen Benutzer. Ohne LFS fehlen später die Modelldateien.
    git lfs install
  3. Programm herunterladen. Damit lädst du die MotionBricks-Software von GitHub und wechselst in ihren Ordner. Die fertigen ONNX-Modelle (ein gängiges Austauschformat für KI-Modelle) sind schon dabei. Die Gewichte von Hugging Face brauchst du also nicht.
    git clone https://github.com/NVlabs/motionbricks
    cd motionbricks
  4. Große Dateien holen. Dieser Befehl lädt die großen Dateien wie Modelle und Bewegungsbeispiele nach. Das kann je nach Leitung ein paar Minuten dauern.
    git lfs pull
  5. Umgebung anlegen und installieren. uv legt eine eigene Python-Umgebung an (den Ordner .venv) und installiert alle Pakete, auch Warp, Newton und TensorRT. Aktivieren musst du die Umgebung nicht, denn das erledigt später „uv run“. Wenn keine roten Fehlermeldungen erscheinen, hat es geklappt.
    uv sync
  6. Ersten Test starten. Dieser Befehl startet die Inbetweener-Demo. Beim ersten Start baut TensorRT einen Plan für deine Grafikkarte, das dauert ein paar Minuten. Der Plan wird im Ordner .trt-cache gespeichert, deshalb geht jeder weitere Start schnell. Danach öffnet sich ein Fenster: Wähle dort Posen aus Clips, platziere sie und lass die Bewegung dazwischen erzeugen.
    uv run python -m app.inbetweener_demo
  7. Ergebnis. Ein Fenster mit dem Inbetweener öffnet sich. Dort setzt du Posen und MotionBricks erzeugt in Echtzeit die Bewegung, die sie verbindet.

macOS

macOS: nicht unterstützt. Das Programm nutzt TensorRT und braucht laut NVIDIA zwingend eine NVIDIA-Grafikkarte. Macs haben so eine Karte nicht. Nimm stattdessen einen Windows- oder Linux-PC mit NVIDIA-Karte oder schau dir die Videos auf der Projektseite an.

Linux

Linux: unterstützt. NVIDIA hat Linux (x86-64) offiziell mit einer RTX 4090 getestet. Du brauchst eine NVIDIA-Grafikkarte mit passendem Treiber, denn das Programm nutzt TensorRT.

  1. Voraussetzungen installieren. Du brauchst eine NVIDIA-Grafikkarte mit installiertem NVIDIA-Treiber. Installiere außerdem Git, Git LFS (eine Git-Erweiterung für große Dateien) und uv (ein Python-Paketmanager, der Python selbst mitbringt). Git und Git LFS bekommst du meist über die Paketverwaltung deiner Distribution, uv über seine offizielle Website. Prüfe alles im Terminal mit den Befehlen hier: Jeder sollte eine Version oder Infos zur Grafikkarte zeigen.
    nvidia-smi
    git --version
    git lfs version
    uv --version
  2. Git LFS einrichten. Dieser Befehl aktiviert Git LFS einmalig für deinen Benutzer. Ohne LFS fehlen später die Modelldateien.
    git lfs install
  3. Programm herunterladen. Damit lädst du die MotionBricks-Software und wechselst in ihren Ordner. Die fertigen ONNX-Modelle (ein gängiges Austauschformat für KI-Modelle) sind schon enthalten. Ein Download von Hugging Face ist für die Demos nicht nötig.
    git clone https://github.com/NVlabs/motionbricks
    cd motionbricks
  4. Große Dateien holen. Dieser Befehl lädt die großen Dateien wie Modelle und Bewegungsbeispiele nach. Das kann ein paar Minuten dauern.
    git lfs pull
  5. Umgebung anlegen und installieren. uv legt eine eigene Python-Umgebung im Ordner .venv an und installiert alle Pakete, darunter Warp, Newton und TensorRT. Aktivieren musst du nichts, denn „uv run“ erledigt das später automatisch.
    uv sync
  6. Ersten Test starten. Dieser Befehl startet die Inbetweener-Demo. Beim ersten Start baut TensorRT einige Minuten lang einen Plan für deine Grafikkarte und speichert ihn in .trt-cache. Danach öffnet sich ein Fenster: Wähle Posen aus Clips, platziere sie und lass die Bewegung dazwischen erzeugen.
    uv run python -m app.inbetweener_demo
  7. Ergebnis. Ein Fenster mit dem Inbetweener öffnet sich. Dort setzt du Posen und MotionBricks erzeugt in Echtzeit die Bewegung, die sie verbindet.

So geht es nach dem ersten Ergebnis weiter

  • In der Scene Preview steuerst du eine Figur durch einen Parcours. Sie läuft, springt über Hindernisse, duckt sich und setzt sich hin. Starten kannst du sie mit: uv run python -m app.scene_preview --scene assets/scenes/soma_gym.scene.json (für den Roboter: g1_gym.scene.json).
  • Mit eigenen Editoren baust du eigene Bausteine und Szenen: uv run python -m app.smart_primitive_editor und uv run python -m app.scene_editor. Eine Schritt-für-Schritt-Einführung findest du im Guided Tutorial unter docs/guided_tutorial.md.
  • Du willst selbst ONNX-Modelle exportieren? Dann lade die Gewichte mit hf download nvidia/MotionBricks --local-dir checkpoints/MotionBricks herunter. Danach exportierst du sie mit uv run --locked --project tools/onnx motionbricks-onnx --model soma --checkpoints checkpoints/MotionBricks/soma. Mit --precision fp16 bekommst du kleinere Modelle in gemischter FP16-Genauigkeit.
  • Wichtig: MotionBricks erzeugt nur Bewegungen und ist keine Steuerung für echte Roboter. Für echte Hardware brauchst du zusätzlich einen eigenen Regler und eine Sicherheitsprüfung.

Das kannst du ausprobieren

Starte die Inbetweener-Demo und setze eine stehende Startpose sowie eine geduckte Zielpose. Schau, wie das Modell den Übergang selbst timt.
Gib in der Demo zwei Zielposen hintereinander vor, etwa Laufen nach links und dann Laufen nach vorn. Prüfe, ob die Figur ohne Abbremsen durch den ersten Punkt läuft.
Wechsle bei der Fortbewegung den Stil von normalem Gehen zu Humpeln oder Zombie-Gang, ohne etwas neu zu trainieren.
Baue im Primitive-Editor einen eigenen Baustein „auf einen Stuhl setzen“ aus drei Schlüsselposen: Annäherung, Kontakt, Sitzen.
Stelle im Szenen-Editor eine kleine Szene mit Bank und Schwert zusammen und lass die Figur in Scene Preview hindurchnavigieren.

Tipps für bessere Ergebnisse

  • Gib mehrere Zielposen statt nur einer vor. Dann erkennt das Modell Tempo und Schwung, und die Bewegung wirkt flüssiger.
  • Lass das Modell die Dauer der Übergänge selbst bestimmen. Ein Durchgang erzeugt 0,6 bis 1,9 Sekunden Bewegung, und längere Abläufe entstehen durch Aneinanderhängen.
  • Beschreibe Interaktionen mit Objekten über wenige, klare Schlüsselposen für Annäherung, Kontakt und Abschluss. Den Rest füllt das Modell aus.
  • Erwarte keine Bewegungen, die in den Trainingsdaten nicht vorkommen. Teste Ungewöhnliches zuerst in der Demo, bevor du darauf aufbaust.

Wenn es hakt

Ohne Nvidia-Grafikkarte läuft die Software nicht. Prüfe vorher, ob aktuelle Treiber sowie CUDA und TensorRT passend installiert sind.

Das Unreal-Engine-Plugin aus der offiziellen Demo ist nicht im Paket. Für Unreal, Unity oder Godot musst du die ONNX-Modelle selbst einbinden.

Die Beispielbewegungen stehen nur unter einer Evaluationslizenz und dürfen nicht in veröffentlichten Spielen verwendet werden.

Die Modelle stehen unter dem NVIDIA Open Model Agreement. Die Lizenz erlischt, wenn du Nvidia wegen Patent- oder Urheberrechtsverletzung durch das Modell verklagst.

Die vollständige Trainings-Pipeline und die kompletten Trainingsdaten fehlen. Eigenes Nachtrainieren ist deshalb nur eingeschränkt möglich.

Für echte Roboter gilt: Die erzeugten Posen sind nicht für die physische Steuerung validiert. Du brauchst einen eigenen Regler, der den Posen folgt.

„out of memory“, Absturz oder der Rechner hängt

Das Modell ist zu groß für deinen Grafikspeicher. Nimm eine kleinere Variante aus der Tabelle oben und schließe andere Programme, vor allem Spiele und Browser mit vielen Tabs.

Es läuft, aber extrem langsam

Wahrscheinlich rechnet der Prozessor statt der Grafikkarte. Bei Ollama zeigt ollama ps in der Spalte PROCESSOR, wie viel auf der GPU läuft. Steht dort „100% CPU“, Grafiktreiber aktualisieren oder eine kleinere Variante nehmen, die komplett in den Grafikspeicher passt.

„ollama“ bzw. „python“ wird nicht gefunden

Das Eingabefenster schließen und neu öffnen, damit es das frisch installierte Programm kennt. Bei Python unter Windows: neu installieren und das Häkchen Add python.exe to PATH setzen.

Windows: „Die Ausführung von Skripts ist auf diesem System deaktiviert“

Das Skript genau mit dem Befehl oben starten: powershell -ExecutionPolicy Bypass -File try_windows.ps1. Das erlaubt die Ausführung nur dieses einen Mal.

Fehlermeldung beim Laden des Modells (Version, „trust_remote_code“, unbekannte Architektur)

Ganz neue Modelle brauchen oft die neueste Programmversion. Bei Ollama: Ollama aktualisieren. Bei Python: pip install -U transformers in der aktivierten Umgebung. Die Model Card nennt meist die genaue Version.

Skripte und Notebook erzeugt Tokenstrom automatisch. Bitte vor dem Ausführen kurz ansehen – sie sind lesbarer Klartext. Lizenz des Modells beachten: Code: Apache 2.0; Modelle: NVIDIA Open Model Agreement.

Frag den KI-Assistenten

Fragen zu diesem Artikel, zur Installation oder zu Hintergründen? Unser Assistent kennt diese Seite und läuft auf unserem eigenen Rechner, nicht in einer fremden Cloud.

Verbinde …

Der Assistent ist eine KI (Gemma 4) und kann sich irren – wichtige Angaben bitte in der Quelle prüfen. Fragen werden nur zum Beantworten genutzt und nach einer Stunde gelöscht. Bitte keine persönlichen Daten eingeben.

Kommentare

Was meinst du dazu? Schon ausprobiert? Schreib es hier, ohne Anmeldung.

  1. Kommentare werden geladen …

Kommentare sind öffentlich. Links sind nicht erlaubt, beleidigende Beiträge löschen wir. Deinen eigenen Kommentar kannst du in diesem Browser jederzeit wieder löschen. Mehr dazu in der Datenschutzerklärung.