# TypeScript on Roku: What the RSG 2.0 SDK Beta Means for TV App Teams

> Roku RSG 2.0 SDK brings TypeScript and SolidJS to Roku, open source under MIT. What the beta and the Nov 11 Q&A reveal, what is still missing and how to plan.

- URL: https://blog.w2bit.com/en/blog/roku-rsg-2-sdk-typescript-tv-apps
- Author: Davidson Simões
- Published: 2026-11-18
- Language: en
- Tags: smarttv, roku, typescript, brightscript, javascript, desenvolvimento
- Also available in Portuguese: https://blog.w2bit.com/blog/roku-rsg-2-sdk-typescript-apps-de-tv

Roku's RSG 2.0 SDK, in public beta since October 29, 2026, lets you write Roku SceneGraph components in TypeScript instead of BrightScript. The UI layer is SolidJS, the code runs on the Hermes JavaScript engine, and the SDK is open source under the MIT license. On November 11 Roku held a live Q&A on the beta and posted a written recap the next day. It is the most useful document so far for anyone deciding what to do: TypeScript apps need Roku OS 16.0, there are no worker threads yet, the Roku Advertising Framework is reached through a BrightScript bridge, and the target for publishing TypeScript apps to the Streaming Store is fall 2027. For teams that already ship TV apps in TypeScript on Samsung, LG, Android TV and Fire TV, Roku stops being the platform where shared code ends. It does not become a React platform, and that distinction shapes the plan.

## TL;DR

- **TypeScript is now an official way to build for Roku.** The SDK is on GitLab and npm under MIT. BrightScript is not deprecated, and the two can coexist in one app.
- **It is a beta, and it is sideload-only.** Streaming Store publishing is expected in 2027; the Q&A gave fall 2027 as the target.
- **The UI framework is SolidJS, not React.** Roku evaluated React Native and rejected it. There is no DOM, no CSS and no browser environment.
- **The gaps are known.** No threads from TypeScript, basic `fetch` only, no stack traces for TypeScript crashes yet, and the 4 MB package limit stays.
- **Focus management moves into TypeScript**, with one bridge point back to BrightScript.

![Architecture of an RSG 2.0 SDK app: a BrightScript scene hosts anchor nodes written in TypeScript with SolidJS, which run on the Hermes thread and send batched updates to the SceneGraph render thread; RAF and other BrightScript code are reached through a bridge](https://blog.w2bit.com/static/images/roku-rsg-2-typescript/architecture.en.webp)

_How the pieces fit: the scene is still SceneGraph, the TypeScript UI mounts through anchor nodes, and updates cross to the render thread once per tick._

## What Roku shipped on October 29

The SDK is published as `@roku-sdk/*` packages on the public npm registry, with the source at `gitlab.com/rokudev/rsg-sdk`; the core package, `@roku-sdk/rsg-ts`, is at version 2.19.1. Roku moved its developer repositories from GitHub to GitLab in October and is accepting merge requests for both the SDK and its documentation.

The `rk` command-line tool does the daily work: `rk create` scaffolds an app, `rk device add` registers a Roku on your network, `rk dev` type-checks, builds, sideloads and launches, and `rk mcp` connects an AI assistant. The prerequisites are specific: a Roku on OS 16.0 or later in developer mode, Node.js 24 or later, and pnpm 11. A generated project keeps a small BrightScript footprint, a `Main.brs` entry point plus one XML scene, and Roku's Dev Summit recap says a future version will remove even that.

Two beta rules matter for planning. You can only sideload: Roku is still building the store side (server-side compilation and bytecode versioning, analytics dashboards with stack traces, static analysis rules), and a separate announcement will mark the end of the beta. And APIs may change: backwards compatibility is a stated goal and Roku says it will deprecate before removing, but during the beta breaking changes are still possible.

## Anchor nodes, SolidJS and two threads

The integration point between the two worlds is the anchor node: a SceneGraph component whose contents are written in TypeScript. You register anchor nodes when the TypeScript engine starts, then place them in a scene by name like any other component. Each declares input and output fields, so a BrightScript scene observes and sets a TypeScript component's fields exactly as it would a BrightScript one. Roku's Two Cowboys example has one cowboy in each language, waving at each other through fields.

Below the anchor node, everything is SolidJS. The guide is explicit that you import from `@roku-sdk/solid`, never from `solid-js`, and the Dev Summit recap gives the version as Solid 1.9. Roku's engineers explained the choice: Solid uses much less memory than React, and the React Native renderer does not map neatly onto SceneGraph. The same recap stresses that the SDK is "not a web framework". Your JSX produces SceneGraph nodes such as `rectangle`, `label` and `group`, laid out in 1920x1080 coordinates.

The threading model is the part to internalize first. TypeScript runs on its own thread with its own tree. Updates to SceneGraph are queued and applied at the start of the next render tick, in order, as one transaction, so the last value written wins. In the other direction, TypeScript cannot query SceneGraph node attributes at runtime. Roku's guidance in the Q&A is that if you find yourself querying nodes you are usually doing it wrong: push data onto nodes from your data models, and for state that changes natively, such as a Video node, register an event callback and keep the value yourself. Each component's type definition says which fields are read-only (they arrive as events), which are writable (set through props) and which events you can listen to.

## Focus is where the model changes most

Anyone who has built a 10-foot UI knows focus handling is where the time goes. The SDK's answer is the focus boundary: a single SceneGraph node holds real focus, and all routing and key handling inside that subtree happens in TypeScript with SolidJS signals. Components opt in with a `useFocusable` hook, read `isFocused()` as a reactive accessor to drive their visuals, and declare the keys they handle in a map. Boundaries nest, so a sidebar and a content area each own their navigation while a root boundary delegates between them.

The bridge to BrightScript is deliberately small: the root boundary writes a `handledKeys` field, and the BrightScript `onKeyEvent` function checks it synchronously and returns at once, without a round trip. Roku contrasts this with native SceneGraph focus, where moving focus means `setFocus(true)` through field observations and key handling is spread across many components.

The documented limits are the ones to read before porting a screen: the boundary does not detect a native dialog taking focus, a child SceneGraph component that calls `setFocus(true)` internally (a `RowList`, for example) leaves the virtual focus stale, and multiple root boundaries in one scene do not coordinate. In the Q&A, Roku's advice for native components was to hand focus to them through the boundary rather than calling set focus directly. Our reading: in shape this is close to the focus libraries TV teams already use on Tizen and webOS web apps, where a JavaScript layer owns focus and the platform only sees key events. The mental model is portable even though the code is not.

![Timeline of the RSG 2.0 SDK: FAQ in June, Dev Summit announcement on September 23, public beta on October 29 (sideload only), live Q&A on November 11, and Streaming Store publishing targeted for fall 2027](https://blog.w2bit.com/static/images/roku-rsg-2-typescript/timeline.en.webp)

_From announcement to publishing: the beta is open now, but store publishing for TypeScript apps is a 2027 event._

## What the November 11 Q&A made explicit

The recap posted on November 12 is worth reading in full. These are the answers we would put in a planning document:

- **Roku OS 16.0 is required to sideload a TypeScript app.** The documentation had said otherwise and was corrected after a developer hit a "not permitted to run TypeScript" error on OS 15.3. Roku says 16.0 and TypeScript both run on its lowest-end devices, known as Liberty and Littlefield.
- **Publishing comes in 2027.** The target for publicly publishing TypeScript apps is fall 2027. Private beta channels can be enabled by a partner team; a developer without a partner engagement manager is limited to sideloading.
- **No threads from TypeScript today.** Roku recognises the issue and gave no timeline. The Dev Summit recap describes the planned interface as similar to Web Workers, and a partner noted there is no task-node equivalent yet, so heavy work competes for the single thread.
- **RAF stays in BrightScript.** The Roku Advertising Framework runs as a BrightScript plugin reached through a bridge. Limit-ad-tracking is only available through RAF, so you read it in BrightScript and bridge it across.
- **`fetch` is basic for now.** No streaming yet. Roku wants at least basic fetch and `AbortController` natively; `URL` and `URLSearchParams` may be polyfilled. There is no reference of which ECMAScript features Hermes supports; the tooling lowers unsupported syntax with Babel, case by case.
- **Testing is Jest, off the device.** Roku's own integration tests run Jest on a laptop, sideload a test app, change fields through ECP and read back the tree. Roku would like to integrate the BrightScript framework Rooibos but has not had the bandwidth.
- **One bug was acknowledged live.** A custom suspend appears to kill the TypeScript thread immediately instead of after the usual window; Roku called it a probable SDK oversight and said it would look at a fix.

## Limits to plan around

The Dev Summit Q&A recap, posted on October 29, fills in the rest. Roku is keeping the 4 MB maximum package size for now. Crash analytics for TypeScript are something Roku wants in place before developers can publish, and Crunchyroll noted that TypeScript component crashes currently have no stack traces. There is no true hot reload: `rk dev --watch` rebuilds and pushes the full package on save.

On performance, Roku says Hermes runs TypeScript faster than BrightScript "in most areas", with benchmarks it has not published. The recap also records that Liberty and Littlefield have no GPU and cannot reach 60 fps, and that Disney's Tim Lee measured the Littlefield round trip at two to four times longer. FlexGrid, the SDK's showcase virtualised grid, runs only in Hermes and is driven only from TypeScript, but it can reuse BrightScript tile components imported from XML, which is what makes a gradual migration realistic.

For build integration, `rk` is built on esbuild with a pipeline API for extra steps and transpilers, and a Roku engineer's note cautions against ejecting the bundler, because packaging and bytecode generation are Roku-specific and will drift. Third-party JavaScript libraries work, with the caveat partners raised that many carry browser or Node dependencies that have to be swapped out, since Hermes runs plain JavaScript.

![What a multi-platform TV team can share with a Roku app on the RSG 2.0 SDK: types, models, API clients and business logic are shareable; the SolidJS UI, SceneGraph components, focus boundaries and BrightScript shims are Roku-specific; DOM, CSS, worker threads and streaming fetch are not available](https://blog.w2bit.com/static/images/roku-rsg-2-typescript/sharing.en.webp)

_Where the shared code ends. The line moves a lot compared with BrightScript, but the UI layer is still written for Roku._

## What this means for teams shipping on many TV platforms

At W2BIT we build Smart TV apps with React and React Native for platforms such as Android TV, LG webOS and Samsung Tizen. In that kind of setup Roku has been the outlier: a separate language, a separate toolchain and, in practice, a separate team or vendor. The RSG 2.0 SDK moves the line. A TypeScript monorepo can now hold the Roku app too, and the parts of a TV product that are not UI, which in our experience is most of the hard logic, can be shared: domain types, catalogue models, API clients, entitlement and playback state, analytics mapping. That is our interpretation, not a Roku claim, and the caveat about Hermes and browser-dependent libraries applies to every shared package.

What cannot be shared is the UI. A React component written for Tizen or Android TV does not become a Roku component; it is rewritten in SolidJS against SceneGraph primitives, with focus expressed through boundaries. Teams that expect "React on Roku" will be disappointed; teams that expect "TypeScript on Roku, with a lean reactive UI layer" will find the work predictable.

The plan we would follow:

1. **Get a device on Roku OS 16.0.** Join the developer beta program if the update has not reached your hardware; nothing TypeScript runs on 15.3.
2. **Build one anchor node, not an app.** Pick a screen where FlexGrid pays off, such as a catalogue shelf, host it inside the existing BrightScript scene, and leave the rest alone. This is the migration path Roku designed for.
3. **Inventory what stays in BrightScript.** RAF, anything that needs threads today, and any component that takes focus natively go on the bridge list, not the port list.
4. **Decide the shared-code boundary early.** Keep shared packages free of DOM, Node and browser APIs and test them under Hermes.
5. **Do not plan a production launch before publishing opens.** Fall 2027 is a target. New BrightScript work can still be structured with the port in mind: components with clean field interfaces move easily.
6. **Watch the forum.** Roku announces each beta release in the RSG 2.0 section of its developer forum, where its engineers answer questions.

## FAQ

### What is the Roku RSG 2.0 SDK?

It is Roku's open-source SDK, released under the MIT license, for building Roku SceneGraph apps in TypeScript. It uses SolidJS for the UI layer, runs on the Hermes JavaScript engine, and includes the `rk` command-line tool, the FlexGrid component and a focus-management system. The public beta started on October 29, 2026.

### Can I publish a TypeScript app to the Roku Streaming Store today?

No. During the beta, apps built with the RSG 2.0 SDK can only be sideloaded. Roku expects Streaming Store support in 2027 and, in its November 11 Q&A, gave fall 2027 as the target for public publishing. Private beta channels require a Roku partner team.

### Does the RSG 2.0 SDK replace BrightScript?

No. Roku says BrightScript remains supported and has no dates for deprecating it, while most of its resources will go to TypeScript. TypeScript and BrightScript components coexist in one app through anchor nodes, so an app can be ported one component at a time.

### Is the RSG 2.0 SDK based on React or React Native?

No. The UI layer is SolidJS, imported through the `@roku-sdk/solid` package. Roku's engineers said they evaluated React Native and rejected it because React is larger than Solid and its renderer does not map well onto SceneGraph.

## Sources

1. Roku Developer Blog, "RSG 2.0 SDK available for beta testing," October 29, 2026. [https://blog.roku.com/developer/rsg-2-0-sdk-beta-starts](https://blog.roku.com/developer/rsg-2-0-sdk-beta-starts)
2. Nicole Sumrall, "RSG 2.0 SDK – Live Q&A Session replay is now available!," Roku Developer Blog, November 12, 2026. [https://blog.roku.com/developer/rsg-2-0-sdk-live-qa-session-replay-is-now-available](https://blog.roku.com/developer/rsg-2-0-sdk-live-qa-session-replay-is-now-available)
3. Roku Developers forum, "RSG 2.0 Live Q&A - Recap," November 12, 2026. [https://forum.developer.roku.com/t/rsg-2-0-live-q-a-recap/11817](https://forum.developer.roku.com/t/rsg-2-0-live-q-a-recap/11817)
4. Roku Developers forum, "Dev Summit 2026 - Q&A Recap," October 29, 2026. [https://forum.developer.roku.com/t/dev-summit-2026-q-a-recap/11740](https://forum.developer.roku.com/t/dev-summit-2026-q-a-recap/11740)
5. Roku Developers forum, "RSG 2.0 SDK FAQs," June 10, 2026. [https://forum.developer.roku.com/t/rsg-2-0-sdk-faqs/11453](https://forum.developer.roku.com/t/rsg-2-0-sdk-faqs/11453)
6. Roku, "Getting started with the RSG 2.0 SDK" (documentation). [https://developer.roku.com/dev/docs/rsg-sdk-standing-docs-getting-started-first-app](https://developer.roku.com/dev/docs/rsg-sdk-standing-docs-getting-started-first-app)
7. Roku, "Focus boundary" (documentation). [https://developer.roku.com/dev/docs/rsg-sdk-standing-docs-guides-focus-management-focus-boundary](https://developer.roku.com/dev/docs/rsg-sdk-standing-docs-guides-focus-management-focus-boundary)
8. Roku Developers forum, "RSG 2.0 public beta: 'not permitted to run TypeScript' on a sideloaded rk create app," October 30, 2026. [https://forum.developer.roku.com/t/rsg-2-0-public-beta-not-permitted-to-run-typescript-on-a-sideloaded-rk-create-app/11748](https://forum.developer.roku.com/t/rsg-2-0-public-beta-not-permitted-to-run-typescript-on-a-sideloaded-rk-create-app/11748)
9. npm, "@roku-sdk/rsg-ts" (package page). [https://www.npmjs.com/package/@roku-sdk/rsg-ts](https://www.npmjs.com/package/@roku-sdk/rsg-ts)
10. Roku Developer Blog, "Developer repositories moved from GitHub to GitLab," October 15, 2026. [https://blog.roku.com/developer/gitlab-move](https://blog.roku.com/developer/gitlab-move)
