HOT-Step CPP : Génération de musique IA locale avec C++ et GGML

Les générateurs de musique cloud sont pratiques, mais ils entraînent des coûts récurrents, téléversent votre matériel créatif vers des services externes et masquent souvent les paramètres de génération sous-jacents. HOT-Step CPP adopte une approche différente : il regroupe la génération de musique IA locale dans une application basée sur un navigateur, soutenue par un moteur natif C++/GGML.

Décrivez une chanson avec une légende et des paroles, sélectionnez vos paramètres de génération et produisez de l'audio stéréo 48 kHz entièrement sur votre propre matériel. Pas de clés API, d'abonnements ou d'exigences d'inférence cloud.

Le projet étend acestep.cpp avec plus de 100 fonctionnalités couvrant la génération, le traitement audio, la séparation des pistes, la transcription MIDI, le mastering, la gestion des modèles et des flux de travail d'entraînement expérimentaux.

Pourquoi HOT-Step CPP est intéressant

HOT-Step CPP combine trois avantages rarement disponibles dans un outil de génération musicale :

Inférence locale — vos paroles, invites et pistes générées restent sur votre machine.
Performance native — le moteur d'inférence est implémenté en C++ et utilise des backends GGML tels que CUDA, Vulkan, Metal ou l'exécution CPU.
Outillage orienté production — la génération n'est que le début ; l'application comprend des reprises, des pistes, du MIDI, du mastering, du traitement VST3, la gestion des paroles, le repainting et l'évaluation de la qualité.

L'application est construite autour d'ACE-Step 1.5, avec également un backend natif expérimental MiniMax-Music3 disponible. Cela la rend utile à la fois comme station de travail créative et comme banc d'essai pour l'ingénierie audio générative locale.

Principaux flux de génération

Auto-Gen

Auto-Gen est conçu pour les utilisateurs qui veulent commencer avec une idée plutôt qu'une spécification complète. Choisissez un genre, fournissez éventuellement un sujet et une langue, et le modèle de langage intégré peut générer :

Des paroles
Une légende de style
Des métadonnées de chanson
Un titre

Vous pouvez choisir des paroles entièrement générées, des paroles écrites à partir d'un sujet, ou un flux instrumental. Le mode aperçu vous permet de modifier les paroles générées avant de les engager dans la génération audio. Une file d'attente série traite un travail à la fois et expose la progression en direct.

Custom-Gen

Custom-Gen fournit un accès direct aux contrôles de génération. Vous pouvez fournir vos propres paroles et légende, sélectionner le titre et l'artiste, et configurer :

BPM
Durée
Tonalité
Signature rythmique
Solveur et planificateur
Mode de guidage
Échelle CFG et contrôles latents
Options de post-traitement

C'est le meilleur flux lorsque la reproductibilité et l'expérimentation des paramètres comptent. Les graines et les métadonnées de génération sont conservées afin que vous puissiez comparer les variations au lieu de vous fier à la mémoire.

Un système d'échantillonnage et de plugins flexible

Le moteur comprend 17 solveurs, 9 planificateurs et 7 modes de guidage. Son architecture de plugins Lua permet d'ajouter de nouveaux solveurs ODE/SDE, planificateurs de bruit, modes de guidage et pipelines de post-traitement sans recompiler le moteur C++.

Pour créer un plugin, placez un fichier .lua dans :

engine/plugins/

Le plugin devient disponible dans l'interface après le prochain lancement. Les plugins peuvent exposer leurs propres curseurs, interrupteurs et listes déroulantes, ce qui rend les méthodes d'échantillonnage orientées recherche utilisables depuis l'interface normale de l'application. Les exemples inclus incluent CFG-MP, SMC-CFG et CFG-Zero⋆.

Cette conception est particulièrement précieuse pour les développeurs : les expériences d'échantillonnage peuvent être distribuées sous forme de petits scripts plutôt que d'exiger que chaque utilisateur compile un binaire personnalisé.

Fonctionnalités de production audio au-delà de la génération

HOT-Step CPP traite la musique générée comme un matériau à éditer et affiner plutôt qu'un fichier final.

Matchering et post-traitement

Le moteur de mastering Matchering correspond à la sonie, l'égalisation et la dynamique par rapport à une piste de référence. Un interrupteur A/B instantané masterisé/non masterisé facilite le jugement de savoir si le traitement a amélioré le résultat. Le traitement fonctionne à 48 kHz natif, évitant un aller-retour de rééchantillonnage inutile.

Un traitement supplémentaire comprend un débruiteur spectral à filtre de Wiener, un Spectral Lifter natif en C++, un polissage neuronal PP-VAE, un DSP Vocal Naturalizer, une mise en mémoire tampon de durée, un rognage automatique et des fondus configurables. Le pipeline interne reste en WAV32, avec export disponible en WAV, MP3 ou FLAC.

StableStep

StableStep re-rend la partie instrumentale d'une piste finie via Stable Audio 3 en utilisant un re-bruitage partiel. Son objectif est de remplacer le fizz du VAE et d'autres artefacts spectraux par des détails plus convaincants tout en laissant les paroles et les voix intactes.

Le flux sépare les voix principales et d'accompagnement avec BS-RoFormer, traite l'instrumental et remixe le matériel vocal. Les utilisateurs peuvent ajuster la force d'affinage et utiliser une invite dérivée de la légende originale.

Deux backends sont disponibles :

GGML : environ 5,8 Go de modèles
ONNX/TensorRT : environ 12 Go de modèles

Les modèles Stable Audio sont distribués sous la licence communautaire Stability AI.

Reprises, pistes et MIDI

Cover Studio

Cover Studio analyse une piste de référence avec Essentia, extrayant BPM, tonalité, énergie et informations timbrales. Il peut générer une reprise assortie au style tout en préservant ou transformant des aspects sélectionnés de la source.

Les contrôles utiles incluent la fidélité de la structure, la préservation de la source, le décalage de hauteur avec aperçus de transposition, la mise à l'échelle du tempo, la séparation des pistes, la recombinaison et des préréglages d'adaptateur par album.

Stem Studio et Stem Builder

Stem Studio utilise un pipeline de séparation en quatre étapes :

BS-RoFormer pour la séparation primaire en six pistes
Mel-Band RoFormer pour l'isolation des voix principales et d'accompagnement
MDX23C pour la sous-séparation de la batterie
HTDemucs pour l'affinage des instruments

La gestion séquentielle de la VRAM maintient l'utilisation maximale sous 3 Go pendant la séparation. Le mixeur interactif prend en charge le multi-solo, les contrôles de volume par piste et l'export ZIP.

Stem Builder fonctionne dans la direction opposée : fournissez une piste source et demandez au moteur DiT de générer des voix, batteries, basses, guitares ou pianos complémentaires. Vous pouvez construire un arrangement de manière itérative au lieu de régénérer toute la chanson.

MIDI Studio

MIDI Studio est un port natif C++/GGML de MuScriptor de Kyutai et Mirelo. Le projet rapporte une validation octet pour octet par rapport à l'implémentation de référence et une accélération GPU ; une piste de 3,5 minutes peut être transcrite en moins d'une minute.

L'outil produit du MIDI multipiste à travers 34 groupes d'instruments plus la batterie. Des modèles petit, moyen et grand sont disponibles, et l'interface affiche un rouleau de piano en direct pendant la transcription. Les utilisateurs peuvent immédiatement comparer l'audio original avec la version MIDI à l'aide d'un curseur de fondu enchaîné et de contrôles de coupure ou de solo par instrument.

Les poids du modèle sont soumis à une porte sur Hugging Face et sous licence CC BY-NC 4.0, donc cette fonctionnalité est destinée à un usage non commercial.

Entraînement de modèles expérimental

Le Training Studio permet aux utilisateurs d'entraîner des adaptateurs de style dans HOT-Step sans Python ni outils de prétraitement externes. Pointez l'application vers un dossier de chansons et elle peut guider le flux à travers :

Création de jeu de données
Analyse locale du BPM et de la tonalité
Récupération des paroles depuis Genius
Légendes IA sensibles à l'audio
Prétraitement des tenseurs
Entraînement LoRA du modèle de planification
Entraînement LoRA du DiT

Les modèles de planification incluent des variantes 0,6B, 1,7B et 4B. Un mode d'audition purement LM vous permet de comparer ce que le planificateur a appris par rapport au modèle de base sans influence du DiT.

Cette fonctionnalité est explicitement expérimentale. Un GPU avec au moins 16 Go de VRAM est recommandé, tandis que l'entraînement DiT en profondeur est mieux adapté aux systèmes avec 24 Go ou plus. Attendez-vous à une utilisation élevée de la mémoire et à un comportement changeant.

Backend MiniMax-Music3

HOT-Step CPP inclut également un port natif rudimentaire C++/GGML de MiniMax-Music3. Le projet le décrit comme une implémentation précoce et, à sa connaissance, la première version du modèle en dehors de Python.

Après avoir installé le pack MiniMax-Music3 via Model Manager, un interrupteur de backend apparaît dans la barre globale. Le pack fait environ 24 Go et nécessite environ 24 Go de VRAM en f16.

Le support actuel est limité à la génération texte-vers-musique en utilisant :

Légende
Paroles
Durée
Graine

Les reprises, le repainting, les pistes, les adaptateurs et l'entraînement ne sont pas encore pris en charge pour ce backend. La sortie est stockée en WAV 44,1 kHz brut. Des variantes quantifiées à plus faible VRAM sont prévues.

Support matériel et plateforme

Des versions précompilées sont disponibles pour :

Plateforme	Options d'accélération
Windows x64	CUDA, Vulkan, CPU
Linux x64	CUDA, Vulkan, CPU
macOS Apple Silicon	Metal

Pour les utilisateurs NVIDIA, CUDA offre les meilleures performances, avec un RTX 2060 ou plus récent recommandé. Vulkan prend en charge AMD, Intel et les anciens matériels NVIDIA. Le mode CPU fonctionne sur toute machine prise en charge mais est nettement plus lent.

Les besoins de stockage typiques sont d'environ 10 Go pour l'application et les modèles de démarrage. L'ensemble de modèles ACE-Step standard nécessite environ 7 Go à télécharger via l'application.

Démarrage rapide avec une version portable

Le chemin d'installation le plus simple est de télécharger une archive de version, de l'extraire et de lancer le script spécifique à la plateforme.

Windows

Téléchargez et extrayez l'archive pour CUDA, Vulkan ou CPU.
Exécutez HOT-Step.bat.
Ouvrez http://localhost:3001 si le navigateur ne s'ouvre pas automatiquement.
Allez dans Models → Get More Models et téléchargez l'ensemble de modèles de démarrage d'environ 7 Go.

Windows 10 ou 11 64 bits est requis. La variante CUDA nécessite des pilotes NVIDIA compatibles, tandis que la variante Vulkan nécessite des pilotes Vulkan 1.1 ou plus récents.

Linux

./HOT-Step.sh

Utilisez Ubuntu 22.04 ou une distribution x86_64 équivalente. Les utilisateurs CUDA ont besoin de pilotes NVIDIA 525 ou plus récents ; les utilisateurs Vulkan ont besoin de pilotes compatibles Vulkan 1.1 et de libvulkan1.

macOS

Sur les systèmes Apple Silicon exécutant macOS 13 ou plus récent :

./HOT-Step.sh

La version inclut Node.js, donc aucune installation Node séparée n'est nécessaire. Si macOS bloque les binaires non signés, supprimez l'attribut de quarantaine une fois :

xattr -cr /chemin/vers/HOT-Step-CPP/

Construction à partir des sources

Clonez le dépôt avec ses sous-modules :

git clone --recursive https://github.com/scragnog/HOT-Step-CPP.git
cd HOT-Step-CPP

Si le dépôt a été cloné sans --recursive, initialisez les dépendances manuellement :

git submodule update --init --recursive

Windows avec CUDA

Installez Visual Studio 2022 Build Tools avec Développement desktop en C++, CUDA Toolkit 12.x ou plus récent avec intégration Visual Studio, CMake 3.14+, Git et Node.js 18–22 LTS. Node.js 24 n'est pas pris en charge.

La commande de construction pratique est :

engine\build.cmd

Pour une construction CMake manuelle :

cd engine
mkdir build
cd build
cmake .. -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES=native
cmake --build . --config Release -j %NUMBER_OF_PROCESSORS%
cd ..\..

macOS avec Metal

Installez Xcode Command Line Tools, CMake, Node.js 18–22 LTS et Git. Ensuite, construisez avec Metal activé :

cd engine
mkdir build && cd build
cmake .. -DGGML_METAL=ON -DGGML_METAL_EMBED_LIBRARY=ON -DCMAKE_BUILD_TYPE=Release
cmake --build . --config Release -j $(sysctl -n hw.ncpu)
cd ../..

L'intégration de la bibliothèque de shaders Metal signifie qu'aucun fichier .metallib externe n'est requis à l'exécution.

Linux

Les constructions CUDA utilisent :

cd engine
mkdir -p build && cd build
cmake .. -DGGML_CUDA=ON -DCMAKE_BUILD_TYPE=Release
cmake --build . -j $(nproc)

Pour Vulkan :

cmake .. -DGGML_VULKAN=ON -DCMAKE_BUILD_TYPE=Release
cmake --build . -j $(nproc)

Pour les constructions CPU uniquement, omettez le drapeau de backend :

cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build . -j $(nproc)

Installez les dépendances du serveur et de l'interface avant de lancer :

cd server && npm install && cd ..
cd ui && npm install && cd ..

Sur Windows, exécutez LAUNCH.bat ; sur macOS et Linux, exécutez ./launch.sh. Le mode production écoute sur le port 3001. Le mode développement utilise le frontend Vite sur le port 3000.

Disposition des modèles

Une construction source attend les fichiers suivants sous models/ :

models/
├── acestep-5Hz-lm-4B-Q8_0.gguf
├── Qwen3-Embedding-0.6B-Q8_0.gguf
├── acestep-v15-turbo-Q8_0.gguf
└── vae-BF16.gguf

Les fichiers recommandés sont approximativement :

Composant	Fichier	Taille
Modèle de langage	`acestep-5Hz-lm-4B-Q8_0.gguf`	4,2 Go
Encodeur de texte	`Qwen3-Embedding-0.6B-Q8_0.gguf`	748 Mo
DiT	`acestep-v15-turbo-Q8_0.gguf`	2,4 Go
VAE	`vae-BF16.gguf`	322 Mo

Des variantes LM plus petites de 0,6B et 1,7B sont disponibles. Les modèles optionnels incluent ScragVAE à 322 Mo, PP-VAE à 644 Mo, les actifs GGML StableStep à 5,8 Go et les actifs ONNX StableStep à 12 Go.

Le Model Manager intégré est généralement plus facile : il fournit des packs de démarrage sélectionnés et un accès à plus de 100 modèles GGUF à travers cinq dépôts Hugging Face, avec des téléchargements simultanés reprenables.

Architecture pour développeurs

Le système est divisé en trois composants coopérants :

Composant	Technologie	Responsabilité
Moteur	C++, CUDA, GGML	Exécute l'inférence de modèles et les opérations audio natives
Serveur	Node.js, TypeScript	Orchestre les travaux, gère les chansons et sert l'application
Interface	React, Vite, TypeScript	Fournit l'interface créative basée sur navigateur

Cette séparation rend le projet abordable de plusieurs directions. Les développeurs C++ peuvent travailler sur l'inférence et le DSP, les développeurs TypeScript peuvent étendre l'orchestration et les API, et les développeurs frontend peuvent ajouter des flux créatifs sans modifier le moteur.

Le moteur prend en charge GGUF et safetensors Hugging Face. Les dossiers safetensors peuvent être déposés dans le répertoire des modèles et sont identifiés avec un badge de format dans l'interface. Les safetensors BF16 produisent une sortie bit par bit identique par rapport au GGUF BF16, et les adaptateurs LoRA fonctionnent avec les deux formats.

Problèmes de construction courants

Quelques problèmes sont particulièrement courants :

Échecs d'installation Node.js 24 : passez à Node.js 22 LTS avec nvm install 22 et nvm use 22.
Erreurs MSVC C2589 : définissez NOMINMAX et, si nécessaire, configurez CMake avec /DNOMINMAX /DWIN32_LEAN_AND_MEAN.
Répertoire CUDA Toolkit manquant : vérifiez CUDA_PATH, installez l'intégration Visual Studio et redémarrez le terminal.
Erreurs d'emplacement du binaire Ninja : Ninja place les binaires directement dans engine/build/, plutôt que dans engine/build/Release/.
Configuration CMake obsolète : supprimez engine/build/ et reconfigurez après avoir changé les versions CUDA ou les paramètres du compilateur.
Erreurs de longueur de chemin Windows : ouvrez un nouveau terminal si des constructions répétées ont étendu PATH via vcvars64.bat.
Blocage Gatekeeper macOS : utilisez xattr -cr sur le répertoire de version extrait.

Qui devrait l'essayer ?

HOT-Step CPP est un excellent choix pour les développeurs, musiciens et créateurs techniquement enclins qui veulent un contrôle local sur la génération de musique IA. C'est plus qu'une démo texte-vers-audio : le projet fournit un moteur natif extensible, une interface sérieuse, des ports de modèles expérimentaux et une collection croissante d'outils pour amener l'audio généré vers une production finie.

Le compromis est la complexité. Les grands modèles peuvent nécessiter un espace disque et une VRAM substantiels, certaines fonctionnalités sont expérimentales, et les flux MiniMax-Music3 et Training Studio évoluent encore. Pour les utilisateurs à l'aise avec les outils IA locaux, cependant, cette même ouverture est l'attrait : vous pouvez inspecter les paramètres, échanger des modèles, écrire des plugins Lua, construire à partir des sources et garder tout le pipeline créatif sur votre propre machine.

Source

scragnog/HOT-Step-CPP : Tournez les boutons. Invoquez des hits ! MAINTENANT AVEC PLUS DE C++ ! Génération de musique IA locale propulsée par GGML