Premiers pas avec Roku RSG 2.0 SDK : guide du débutant pour le développement Roku en TypeScript

Shishupal Singh Shakya
By Shishupal Singh Shakya
Nov 18, 2026 9 min read

Points clés

  • RSG 2.0 apporte le développement TypeScript et TSX sur Roku, en complément du BrightScript traditionnel tout en permettant des pratiques de développement modernes.
  • Les prérequis incluent un appareil Roku avec OS 16.0 ou ultérieur, Node.js 24+ et pnpm 11 pour l’environnement de développement.
  • Les développeurs doivent activer le mode développeur sur les appareils Roku et configurer la machine de développement pour autoriser le sideloading et les tests d’applications.
  • L’outil en ligne de commande rk facilite la création, la construction, le test et le déploiement des applications RSG 2.0 sur les appareils Roku.
  • RSG 2.0 est en bêta publique ; les applications ne peuvent pas encore être publiées sur le Roku Streaming Store et doivent être installées via sideloading.
  • Les composants TypeScript peuvent coexister avec le BrightScript traditionnel dans la même application, permettant une migration progressive des approches de développement héritées.

Introduction

Roku a traditionnellement pris en charge le développement d’applications avec BrightScript et XML, Roku SceneGraph servant de cadre sous-jacent pour construire les interfaces utilisateur télévisées.

Au fur et à mesure que les exigences du développement d’applications évoluent, les développeurs recherchent de plus en plus des langages de programmation modernes, un code structuré, des composants réutilisables et des outils de développement améliorés.

Pour accompagner cette évolution, Roku a introduit le Roku SceneGraph 2.0 (RSG 2.0) SDK, qui apporte le développement basé sur TypeScript à la plateforme Roku.

Avec RSG 2.0, les développeurs peuvent créer des applications Roku en utilisant TypeScript et TSX tout en continuant à utiliser le cadre de rendu SceneGraph existant.

Un point important est que RSG 2.0 ne remplace pas BrightScript. Il fournit plutôt une approche de développement supplémentaire qui permet la coexistence de composants TypeScript et BrightScript traditionnels au sein d’une même application.

Cela rend le SDK pertinent à la fois pour de nouveaux projets Roku et les équipes de développement explorant une transition progressive depuis le développement Roku traditionnel.

Dans cet article, nous vous guiderons à travers les prérequis, la configuration de l’environnement, l’installation du SDK, la création du projet et les étapes nécessaires pour exécuter votre première application RSG 2.0.

Qu'est-ce que le SDK Roku RSG 2.0 ?

RSG 2.0 est le SDK de développement de Roku basé sur TypeScript pour créer des applications utilisant le framework Roku SceneGraph.

Traditionnellement, les développeurs utilisaient :

  • BrightScript : pour implémenter la logique applicative, les intégrations d’API et les fonctionnalités métier.
  • XML : pour définir les composants UI, leurs propriétés et leurs relations.
  • SceneGraph : pour afficher l’interface utilisateur de l’application.

RSG 2.0 introduit TypeScript et TSX comme moyen supplémentaire pour développer la logique applicative et les composants d’interface utilisateur.

Quelques-unes de ses principales fonctionnalités incluent :

  • Développement d’applications basé sur TypeScript.
  • Prise en charge de TSX pour la création de composants UI.
  • Intégration de SolidJS pour le développement réactif d’UI.
  • Composants TypeScript réutilisables.
  • Support des composants BrightScript et XML existants.
  • Configuration d’application basée sur TypeScript.
  • Fonctionnalités de tests unitaires et d’intégration.
  • Outils modernes de développement et de débogage.

Il est important de noter que RSG 2.0 n’est pas un framework basé sur le web. Il n’utilise ni HTML, ni CSS, ni rendu par navigateur. Les composants TypeScript créent finalement des nœuds SceneGraph, qui sont affichés par la plateforme Roku.

Pour une compréhension plus complète, consultez la  vue d’ensemble officielle du SDK RSG 2.0.

Prérequis pour le développement de RSG 2.0

Avant de créer une application RSG 2.0, les développeurs doivent préparer l’environnement de développement requis.

Les prérequis suivants sont documentés dans le guide de démarrage actuel de Roku.

Exigence

Objectif

Appareil Roku

Exécution et test de l’application

Roku OS 16.0 ou version ultérieure

Version requise du logiciel de l’appareil

Node.js 24 ou version ultérieure

Exécution de l’environnement de développement

pnpm version 11

Gestion des dépendances du projet

Éditeur de code

Écriture et maintenance du code TypeScript

Mode développeur

Installation des applications via le sideloading

Accès au registre npm

Téléchargement des paquets SDK

Connaissances techniques recommandées

Les développeurs devraient également avoir une compréhension de base de :

  • Les fondamentaux de JavaScript et TypeScript.
  • TSX et développement basé sur les composants.
  • Roku SceneGraph.
  • Concepts de programmation asynchrone de base.
  • Les fondamentaux de SolidJS pour le développement d’interfaces réactives.

Les développeurs venant de BrightScript peuvent apprendre progressivement le modèle de programmation TypeScript tout en continuant à exploiter leurs connaissances Roku existantes.

Exigence pour l’appareil : L’appareil Roku et l’ordinateur de développement doivent être connectés au même réseau afin que les outils de développement puissent communiquer avec l’appareil.

Pour plus d’informations, consultez la documentation officielle de Roku : Premiers pas avec le SDK RSG 2.0.

Configuration de l’environnement de développement Roku

Une fois les prérequis disponibles, l'étape suivante consiste à configurer le dispositif Roku et la machine de développement.

Étape 1 : Activer le mode développeur sur Roku

Les applications Roku développées avec RSG 2.0 sont installées sur les appareils de développement via un processus appelé sideloading.

Pour activer le mode développeur :

  1. Utilisez la télécommande Roku et appuyez trois fois sur Home, deux fois sur Haut, puis sur Droite, Gauche, Droite, Gauche et Droite.
  2. L'écran des paramètres développeur apparaîtra.
  3. Notez l'adresse IP de l'appareil Roku.
  4. Activez l'installateur d'applications de développement.
  5. Acceptez le contrat de licence des outils développeur.
  6. Définissez un mot de passe développeur.
  7. Laissez l'appareil Roku redémarrer.

Après le redémarrage, l’appareil sera prêt pour le développement d’applications et le sideloading.

Pour des instructions détaillées, consultez  Activation du mode développeur sur Roku.

Étape 2 : Installer Node.js et pnpm

RSG 2.0 utilise Node.js et pnpm pour gérer l’environnement de développement et les dépendances du projet.

Assurez-vous que les versions suivantes sont installées :

  • Node.js 24 ou ultérieure.
  • pnpm 11.

Vous pouvez vérifier les versions installées via le terminal :

node -v

pnpm -v

Si les versions installées répondent aux exigences de Roku, vous pouvez poursuivre avec la création de votre première application.

Étape 3 : Assurer l’accès au registre npm

Les packages du SDK RSG 2.0 sont distribués via le registre de packages npm sous l’espace de noms @roku-sdk.

Par conséquent, la machine de développement doit pouvoir accéder à :

https://registry.npmjs.org

La documentation officielle Getting Started précise que les packages du SDK sont publics, donc aucun compte de registre distinct ni jeton d’authentification n’est nécessaire pour les télécharger.

Créer votre première application RSG 2.0

Roku fournit un outil en ligne de commande appelé rk pour créer, construire, tester et exécuter des applications RSG 2.0.

L’outil est distribué via le paquet @roku-sdk/tooling.

Suivez ces étapes pour créer votre première application.

Étape 1 : Créer un nouveau projet

Ouvrez le terminal et exécutez :

npx --package @roku-sdk/tooling rk create my-first-app

Ici :

  • npx exécute le paquet requis sans nécessiter une installation globale séparée.
  • @roku-sdk/tooling fournit les outils de développement en ligne de commande de Roku.
  • rk create génère une nouvelle application.
  • my-first-app est le nom du projet.

La commande génère la structure de l’application et installe les dépendances SDK requises.

Étape 2 : Naviguer vers le répertoire du projet

Une fois le projet créé, rendez-vous dans son dossier :

cd my-first-app

Étape 3 : Exécuter l’application

Exécutez la commande suivante :

npx rk dev

La commande de développement effectue la construction nécessaire, la vérification des types, le sideloading et le lancement de l’application sur l’appareil Roku configuré.

Les développeurs peuvent également installer le lanceur CLI optionnel pour exécuter rk directement sans utiliser le préfixe npx à chaque fois.

Pour plus d’informations, consultez le Guide de démarrage RSG 2.0 officiel.

Comprendre la structure du projet généré

Après la création de l’application, Roku génère une structure de projet prédéfinie contenant les fichiers essentiels de configuration et de source.

Voici quelques fichiers et dossiers importants :

Fichier / Répertoire

Finalité

package.json

Contient les dépendances du projet ainsi que les scripts de construction, tests, linting et vérification des types.

pnpm-workspace.yaml

Définit la configuration de l’espace de travail pnpm et les paramètres du script d’installation requis.

roku-config.ts

Contient la configuration de la construction de l’application, le point d’entrée et les paramètres du manifeste.

src/index.ts

Point d’entrée de l’application responsable d’enregistrer les nœuds d’ancrage TypeScript.

src/components/

Contient les composants de l’application en TypeScript.

src/compiled-components/

Contient les fichiers des composants SceneGraph générés.

pkg/

Contient les ressources et fichiers de packaging de l’application Roku.

Comprendre ces fichiers aide les développeurs à identifier où sont maintenues la configuration de l’application, l’implémentation des composants et les ressources liées à la construction.

Par exemple, src/index.ts est un point de départ important car il initialise l’application TypeScript et enregistre les composants à monter dans SceneGraph.

De même, roku-config.ts fournit un emplacement centralisé pour gérer la configuration de l’application et de la construction.

La structure exacte du projet peut varier selon la version du SDK et les exigences du projet.

Connexion d’un appareil Roku à l’environnement de développement

Après avoir créé l’application, les développeurs doivent configurer l’appareil Roku afin que l’outil rk puisse installer et lancer les applications dessus.

Tout d’abord, ajoutez l’appareil Roku en utilisant son adresse IP :

rk device add 192.168.1.42 --name living-room

Remplacez l’adresse IP d’exemple par l’adresse IP réelle de votre appareil Roku.

Ensuite, configurez le mot de passe développeur :

rk device update living-room --password

Définissez l’appareil comme cible de développement active :

rk device set-active living-room

Enfin, vérifiez la configuration de l’appareil :

rk device ls

Une fois que l’appareil apparaît comme actif, l’environnement de développement est prêt à déployer l’application.

Exécuter et vérifier votre première application

Avec le projet et l’appareil Roku configurés, exécutez :

rk dev

La commande effectue les opérations suivantes :

  1. Vérifie les types TypeScript.
  2. Compile l’application.
  3. Installe l’application sur l’appareil Roku actif.
  4. Lance l’application.

Si tout est configuré correctement, l’application devrait se lancer sur le téléviseur et afficher un titre et un sous-titre centrés.

Si l’application ne se lance pas correctement, les développeurs peuvent utiliser :

rk dev --console

Cette commande donne accès à la sortie console de l’appareil, aidant les développeurs à identifier les erreurs de démarrage et autres problèmes.

La commande rk dev prend aussi en charge des options utiles telles que :

  • --device : Sélectionne un appareil Roku spécifique.
  • --watch : Reconstruit et redéploie automatiquement lorsque les fichiers changent.
  • --console : Diffuse la sortie console de l’appareil en continu.
  • --debug : Exécute l’application en mode débogage pour attacher un débogueur.

Ces options rendent le flux de développement plus pratique lors de la création et de la validation des applications.

Considérations importantes avant de démarrer le développement

Avant d’adopter RSG 2.0 pour un projet, les développeurs doivent comprendre sa disponibilité actuelle et ses limitations.

Disponibilité en version bêta : En novembre 2026, RSG 2.0 est en bêta publique. La documentation de Roku indique que les API et la documentation peuvent évoluer durant cette période.

Publication des applications : Les applications développées avec RSG 2.0 ne peuvent pas encore être publiées sur le Roku Streaming Store durant la phase bêta. Les applications peuvent être installées et évaluées via le sideloading.

Compatibilité des appareils : Les prérequis de développement documentés spécifient Roku OS 16.0 ou version ultérieure. Les développeurs doivent vérifier les exigences officielles les plus récentes avant de commencer la mise en œuvre.

Adoption progressive : Les applications BrightScript et XML existantes n’ont pas besoin d’être réécrites immédiatement. Les composants TypeScript peuvent être introduits progressivement aux côtés des composants existants.

Pour la planification du projet, il est important de distinguer entre l’évaluation du SDK, le développement d’une application et son adoption pour la distribution en production.

Conclusion

Commencer avec le SDK Roku RSG 2.0 implique de comprendre son modèle de développement, de préparer l’environnement requis, d’installer les outils du SDK, de créer un projet et de connecter un appareil Roku.

L’introduction de TypeScript et TSX offre aux développeurs Roku une autre approche pour construire des applications SceneGraph tout en assurant la compatibilité avec le développement traditionnel en BrightScript et XML.

L’outil en ligne de commande rk simplifie également des activités de développement importantes, telles que la création de projet, la vérification des types, la compilation, le sideloading et l’exécution de l’application.

Pour les développeurs débutant avec RSG 2.0, il est recommandé de commencer par créer une petite application, de comprendre la structure générée du projet et de la faire fonctionner avec succès sur un appareil Roku avant de passer à des développements d’applications plus complexes.

Une fois la configuration initiale terminée, les développeurs peuvent explorer plus en détail les concepts clés du SDK, les possibilités de développement d’interface utilisateur, les outils de test et les fonctionnalités avancées.

Documentation officielle et références Roku

Les ressources officielles suivantes ont été utilisées lors de la préparation de cet article :

  1. Présentation du SDK RSG 2.0
  2. Prise en main du SDK RSG 2.0
  3. Activation du mode développeur
  4. Premiers pas – Section documentation RSG 2.0

Note éditoriale : RSG 2.0 évolue durant sa phase bêta. Les développeurs doivent toujours se référer à la documentation officielle Roku la plus récente pour les exigences du SDK, les versions des packages, les commandes et les restrictions de publication.