Key takeaways
- RSG 2.0 brings TypeScript and TSX development to Roku, complementing traditional BrightScript while enabling modern development practices.
- Prerequisites include a Roku device with OS 16.0 or later, Node.js 24+, and pnpm 11 for the development environment.
- Developers must enable developer mode on Roku devices and configure the development machine to enable sideloading and application testing.
- The rk command-line tool simplifies creating, building, testing and deploying RSG 2.0 applications to Roku devices.
- RSG 2.0 is in public beta; applications cannot currently be published to the Roku Streaming Store and must be installed through sideloading.
- TypeScript components can coexist with traditional BrightScript in the same application, enabling gradual migration from legacy development approaches.
Introduction
Roku has traditionally supported application development using BrightScript and XML, with Roku SceneGraph serving as the underlying framework for building television user interfaces.
As application development requirements evolve, developers increasingly look for modern programming languages, structured code, reusable components and improved development tools.
To support this evolution, Roku introduced the Roku SceneGraph 2.0 (RSG 2.0) SDK, which brings TypeScript-based development to the Roku platform.
With RSG 2.0, developers can build Roku applications using TypeScript and TSX while continuing to use the existing SceneGraph rendering framework.
One important point is that RSG 2.0 does not replace BrightScript. Instead, it provides an additional development approach that allows TypeScript and traditional BrightScript components to coexist within the same application.
This makes the SDK relevant for both new Roku projects and development teams exploring a gradual transition from traditional Roku development.
In this article, we will walk through the prerequisites, environment setup, SDK installation, project creation and steps required to run your first RSG 2.0 application.
What is Roku RSG 2.0 SDK?
RSG 2.0 is Roku's TypeScript-based development SDK for building applications using the Roku SceneGraph framework.
Traditionally, developers used:
- BrightScript: To implement application logic, API integrations and business functionality.
- XML: To define UI components, their properties and relationships.
- SceneGraph: To render the application's user interface.
RSG 2.0 introduces TypeScript and TSX as another way to develop application logic and user interface components.
Some of its key capabilities include:
- TypeScript-based application development.
- TSX support for creating UI components.
- SolidJS integration for reactive UI development.
- Reusable TypeScript components.
- Support for existing BrightScript and XML components.
- TypeScript-based application configuration.
- Unit and integration testing capabilities.
- Modern development and debugging tools.
Importantly, RSG 2.0 is not a web-based framework. It does not use HTML, CSS or browser rendering. TypeScript components ultimately create SceneGraph nodes, which are rendered by the Roku platform.
For a broader understanding, refer to the official RSG 2.0 SDK Overview.
Prerequisites for RSG 2.0 development
Before creating an RSG 2.0 application, developers need to prepare the required development environment.
The following prerequisites are documented in Roku's current Getting Started guide.
Requirement | Purpose |
Roku device | Running and testing the application |
Roku OS 16.0 or later | Required device software version |
Node.js 24 or later | Running the development environment |
pnpm version 11 | Managing project dependencies |
Code editor | Writing and maintaining TypeScript code |
Developer mode | Installing applications through sideloading |
npm registry access | Downloading SDK packages |
Technical knowledge recommended
Developers should also have a basic understanding of:
- JavaScript and TypeScript fundamentals.
- TSX and component-based development.
- Roku SceneGraph.
- Basic asynchronous programming concepts.
- SolidJS fundamentals for reactive UI development.
Developers coming from BrightScript can gradually learn the TypeScript programming model while continuing to work with their existing Roku knowledge.
Device requirement: The Roku device and development computer should be connected to the same network so that the development tools can communicate with the device.
For additional information, refer to Roku's official Getting Started with the RSG 2.0 SDK.
Setting up the Roku development environment
Once the prerequisites are available, the next step is to configure the Roku device and development machine.
Step 1: Enable developer mode on Roku
Roku applications developed using RSG 2.0 are installed on development devices through a process called sideloading.
To enable developer mode:
- Use the Roku remote and press Home three times, Up twice, followed by Right, Left, Right, Left and Right.
- The developer settings screen will appear.
- Note the Roku device's IP address.
- Enable the Development Application Installer.
- Accept the Developer Tools License Agreement.
- Set a developer password.
- Allow the Roku device to restart.
After restarting, the device will be ready for application development and sideloading.
For detailed instructions, refer to Activating Developer Mode on Roku.
Step 2: Install Node.js and pnpm
RSG 2.0 uses Node.js and pnpm to manage the development environment and project dependencies.
Ensure that the following versions are installed:
- Node.js 24 or later.
- pnpm 11.
You can verify the installed versions using the terminal:
node -v
pnpm -v
If the installed versions meet Roku's requirements, you can proceed with creating your first application.
Step 3: Ensure npm registry access
The RSG 2.0 SDK packages are distributed through the npm package registry under the @roku-sdk namespace.
Therefore, the development machine must have access to:
https://registry.npmjs.org
The official Getting Started documentation states that the SDK packages are publicly available, so a separate registry account or authentication token is not required for downloading them.
Creating your first RSG 2.0 application
Roku provides a command-line tool called rk for creating, building, testing and running RSG 2.0 applications.
The tool is distributed through the @roku-sdk/tooling package.
Follow these steps to create your first application.
Step 1: Create a new project
Open the terminal and execute:
npx --package @roku-sdk/tooling rk create my-first-app
Here:
- npx executes the required package without requiring a separate global installation.
- @roku-sdk/tooling provides Roku's development command-line tools.
- rk create generates a new application.
- my-first-app is the project name.
The command generates the application structure and installs the required SDK dependencies.
Step 2: Navigate to the project directory
Once the project is created, navigate into it:
cd my-first-app
Step 3: Run the application
Execute the following command:
npx rk dev
The development command performs the required development build, type checking, sideloading and application launch on the configured Roku device.
Developers can also install the optional CLI launcher to execute rk directly without using the npx prefix each time.
For more information, refer to the official RSG 2.0 Getting Started Guide.
Understanding the generated project structure
After creating the application, Roku generates a predefined project structure containing the essential configuration and source files.
The following are some important files and directories:
File / Directory | Purpose |
package.json | Contains project dependencies and scripts for building, testing, linting and type checking. |
pnpm-workspace.yaml | Defines the pnpm workspace configuration and required install-script settings. |
roku-config.ts | Contains application build configuration, entry point and manifest settings. |
src/index.ts | Application entry point responsible for registering TypeScript anchor nodes. |
src/components/ | Contains TypeScript application components. |
src/compiled-components/ | Contains generated SceneGraph component files. |
pkg/ | Contains Roku application resources and packaging files. |
Understanding these files helps developers identify where application configuration, component implementation and build-related resources are maintained.
For example, src/index.ts is an important starting point because it initializes the TypeScript application and registers the components that need to be mounted into SceneGraph.
Similarly, roku-config.ts provides a centralized location for managing application and build configuration.
The exact project structure may vary depending on the SDK version and project requirements.
Connecting a Roku device to the development environment
After creating the application, developers need to configure the Roku device so that the rk tool can install and launch applications on it.
First, add the Roku device using its IP address:
rk device add 192.168.1.42 --name living-room
Replace the sample IP address with the actual IP address of your Roku device.
Next, configure the developer password:
rk device update living-room --password <PASSWORD>
Set the device as the active development target:
rk device set-active living-room
Finally, verify the device configuration:
rk device ls
Once the device appears as active, the development environment is ready to deploy the application.
Running and verifying your first application
With the project and Roku device configured, execute:
rk dev
The command performs the following operations:
- Checks TypeScript types.
- Builds the application.
- Installs the application on the active Roku device.
- Launches the application.
If everything is configured correctly, the application should launch on the television and display a centered title and subtitle.
If the application does not launch successfully, developers can use:
rk dev --console
This command provides access to the device console output, helping developers identify startup errors and other issues.
The rk dev command also supports useful options such as:
- --device: Selects a specific Roku device.
- --watch: Automatically rebuilds and redeploys when files change.
- --console: Streams device console output.
- --debug: Runs the application in debug mode for debugger attachment.
These options make the development workflow more convenient when building and validating applications.
Important considerations before starting development
Before adopting RSG 2.0 for a project, developers should understand its current availability and limitations.
Beta availability: As of November 2026, RSG 2.0 is in public beta. Roku's documentation states that APIs and documentation may change during this period.
Application publishing: Applications developed using RSG 2.0 cannot currently be published to the Roku Streaming Store during the beta period. Applications can be installed and evaluated through sideloading.
Device compatibility: The documented development prerequisites specify Roku OS 16.0 or later. Developers should verify the latest official requirements before beginning implementation.
Gradual adoption: Existing BrightScript and XML applications do not need to be rewritten immediately. TypeScript components can be introduced incrementally alongside existing components.
For project planning, it is important to distinguish between evaluating the SDK, developing an application and adopting it for production distribution.
Conclusion
Getting started with Roku RSG 2.0 SDK involves understanding its development model, preparing the required environment, installing the SDK tooling, creating a project and connecting a Roku device.
The introduction of TypeScript and TSX provides Roku developers with another approach to building SceneGraph applications while maintaining compatibility with traditional BrightScript and XML development.
The rk command-line tool also simplifies important development activities, including project creation, type checking, building, sideloading and application execution.
For developers who are new to RSG 2.0, the recommended starting point is to create a small application, understand the generated project structure and successfully run it on a Roku device before moving towards more complex application development.
Once the initial setup is complete, developers can explore the SDK's core concepts, UI development capabilities, testing tools and advanced features in greater detail.
Official roku documentation and references
The following official resources were used while preparing this article:
- RSG 2.0 SDK Overview
- Getting Started with the RSG 2.0 SDK
- Activating Developer Mode
- Getting Started – RSG 2.0 Documentation Section
Editorial note: RSG 2.0 is evolving during its beta period. Developers should always refer to the latest official Roku documentation for SDK requirements, package versions, commands and publishing restrictions.
