Roku has provided the first public preview of Roku OS 16.0, giving streaming-app developers an early look at a major collection of new SceneGraph and BrightScript capabilities coming to the platform.
Roku posted the preview on September 14, 2026. The company says OS 16.0 is currently being shared with developer beta partners under NDA, while the public developer release notes reveal some of the changes that developers can prepare for before the operating system begins its wider rollout.
The update is particularly interesting because it targets several areas that matter directly to modern TV applications: richer GPU-accelerated interfaces, better grid focus customization, real-time server communication, cleaner BrightScript development, and more predictable 2D graphics behavior.
Roku OS 16.0 also arrives just ahead of Roku’s 2026 Developer Summit on September 23–24, where Roku has already said it plans to discuss major SDK and developer-workflow improvements.
For viewers, many of these changes may initially be invisible. For streaming developers, however, OS 16.0 could significantly expand what can be built inside Roku applications.
What Is Roku OS 16.0?
Roku OS 16.0 is the next major version of Roku’s television operating system.
Roku applications are primarily built using SceneGraph, Roku’s XML-based interface framework, together with BrightScript, the scripting language used for app behavior and business logic.
Roku OS 16.0 expands both technologies.
The company’s current public preview highlights a new SceneGraph Effect node, greater control over ArrayGrid focus indicators, animation for array-valued fields, Server-Sent Events support, native WebSocket communication, relaxed conditional-compilation rules, deeper BrightScript stacks, and several changes to Roku’s 2D graphics APIs.
Importantly, this is still a developer preview/beta, not a general consumer release.
Roku specifically says developers participating in the beta should provide private feedback through its Centercode beta program while the release remains under NDA.
Roku OS 16.0 Features at a Glance
| Roku OS 16.0 Features | What It Does | Why Developers Should Care |
|---|---|---|
| SceneGraph Effect node | Adds GPU-accelerated rounded corners, borders and gradients | More modern TV interfaces with less custom artwork |
| ArrayGrid focus customization | Exposes the grid focus-indicator Poster | Better visual consistency across custom content grids |
| Array-value animation | Enables animation of array-valued fields | Useful for animated effects and UI transitions |
| Server-Sent Events | Adds SSE handling to roUrlTransfer | Enables one-way real-time server updates |
| roWebSocket | Adds bi-directional WebSocket communication | Useful for live and interactive app experiences |
| Conditional compilation update | Undefined values now default to false | Easier shared-library and debug-feature management |
| Larger BrightScript stack | Raises maximum stack depth | More flexibility for complex application logic |
| ifDraw2D changes | Drawing functions return success/failure Booleans | Better graphics debugging and future compatibility |
| Better graphics debugging and future compatibility | Controls whether returned bitmaps can be modified | Clearer texture-memory behavior |
New SceneGraph Effect Node Brings More Modern Visuals
One of the biggest Roku OS 16.0 additions is a new Effect node for SceneGraph. The Effect node allows developers to apply GPU-accelerated visual styling to existing Poster and Rectangle nodes. Roku specifically highlights rounded corners, borders, linear gradients, and radial gradients.
This can make a significant difference in television app design.
Modern streaming interfaces often rely heavily on rounded artwork cards, gradient overlays, highlighted content tiles, and borders around the currently focused item. Previously, developers might have needed extra image assets, masks, or custom layout techniques to create some of these effects.
With Roku OS 16.0, those effects can become properties of the SceneGraph interface itself.
The Effect node includes a supported field so applications can determine whether a device supports the shader-based rendering. If the underlying hardware lacks the necessary GPU capability—or effects are otherwise unavailable—the normal node still renders without the effect.
That fallback behavior is particularly important across Roku’s large hardware ecosystem.
Rounded Corners and Gradients No Longer Need to Be Baked Into Artwork
A practical advantage of the Effect node is that designers may no longer need to create separate versions of artwork just to achieve visual treatment.
For example, a streaming app could use the same poster image while SceneGraph applies a rounded-corner radius dynamically.
Roku’s documentation also shows options for applying gradients to either the content area, border area, or both.
That creates more flexibility for dynamic interfaces.
A developer could potentially change the look of cards depending on content state, focus, subscription status, recommendation type, or another application condition without requesting a new visual asset from a server.
It also makes it easier for a design system to maintain consistent styling throughout different screens.
For larger streaming applications containing hundreds of interface states, reducing dependence on pre-rendered UI assets can simplify both development and maintenance.
ArrayGrid Focus Indicators Become More Customizable
TV interfaces depend heavily on focus states.
Unlike a smartphone, where users tap directly on an object, Roku viewers navigate using directional buttons on a remote. The interface therefore needs to clearly communicate which tile is currently selected.
Roku OS 16.0 exposes the Poster node used by ArrayGrid for its focus indicator through a public focusFeedbackPoster field.
That gives developers much greater control over how focused content appears.
The same new Effect node can also be applied to this focus indicator, making it possible to match rounded cards or more unusual shapes.
This matters for components based on ArrayGrid, including interfaces such as MarkupGrid and RowList.
Instead of having custom content cards that look one way and a system-generated focus outline that does not quite match them, developers can bring those visual treatments closer together.
For streaming applications with highly branded interfaces, this could make navigation feel considerably more polished.
Roku OS 16.0 Adds Animation for Array-Valued Fields
The public Roku preview also says OS 16.0 introduces support for animating array-valued fields.
This may sound highly technical, but it connects directly to the new visual-effects system.
Many visual properties—such as multiple corner radii or other collections of values—are represented as arrays rather than a single number.
Animating array fields lets developers transition those values smoothly over time.
That opens the door to more sophisticated focus animations and transitions without manually updating every value in application code.
The change reinforces one of the broader themes of Roku OS 16.0: giving SceneGraph applications a richer visual vocabulary while keeping the logic within Roku’s native framework.
WebSocket Support Enables Real-Time Two-Way Communication
Another major addition is roWebSocket.
Roku says the new component allows applications to connect to remote WebSocket servers and communicate bi-directionally according to the WebSocket protocol.
Traditional HTTP requests typically follow a simple pattern: the app requests something, the server responds, and the connection ends or waits for another request.
WebSockets can maintain an active connection so either side can send new information when required.
That can be useful for applications involving rapidly changing information or interactive experiences.
Examples could include live sports statistics, synchronized viewing features, interactive events, real-time dashboards, game-like experiences, live audience features, or continuously changing account information.
Developers have had ways to build networked experiences on Roku before, but providing a dedicated WebSocket component creates a much cleaner platform-level option.
Server-Sent Events Come to roUrlTransfer
Roku OS 16.0 also adds Server-Sent Events, or SSE, to roUrlTransfer.
Unlike WebSockets, SSE is primarily designed for communication moving in one direction: from the server to the application.
Roku says roUrlTransfer can now inspect response headers, recognize the continuous event stream, and deliver incoming events to the application as roUrlEvent messages as they arrive.
That can be valuable when an application needs continual server updates but does not require full two-way communication.
For example, a streaming app could receive updated availability information, changing scores, status updates, refreshed metadata, or other server-driven events without repeatedly polling an endpoint every few seconds.
Using persistent event streams can make some applications more efficient and more responsive.
Combined with WebSockets, Roku OS 16.0 significantly expands the options available for real-time network communication.
BrightScript Conditional Compilation Gets Easier
Roku is also addressing a smaller but useful developer pain point.
In Roku OS 16.0, undefined conditional-compilation values used in #if or #elseif statements are treated as false instead of generating a compile error.
This is especially useful for developers maintaining reusable libraries.
A library might contain optional debugging, analytics, testing, or logging behavior controlled by a compile-time flag. Previously, downstream applications could need to explicitly define that value even when they had no intention of enabling the feature.
With the new behavior, an unused flag can simply remain undefined.
Roku says the change should not break existing applications because applications that currently compile successfully already define the values they rely on.
BrightScript Gets a Larger Maximum Stack Depth
Roku OS 16.0 also increases the maximum BrightScript program stack depth.
Roku has not publicly highlighted a new numeric limit in the preview material surfaced so far, but the change should give more headroom to complex call chains.
Stack depth can become relevant in larger applications where functions call other functions repeatedly or where frameworks introduce additional abstraction layers.
Most straightforward Roku apps may never notice the difference.
For complex streaming applications, shared libraries, or deeper application architectures, however, the expanded limit may reduce the chance of hitting previous stack constraints.
2D Graphics APIs Now Report Whether Drawing Succeeded
Roku OS 16.0 also changes several ifDraw2D graphics functions. Now return a Boolean rather than Void, giving developers an explicit success or failure result.
This provides more useful debugging behavior.
Roku is also preparing developers for stricter handling of a particular graphics pattern: modifying a bitmap after it has already been drawn to the screen but before SwapBuffers().
Under OS 16.0, this can still work, but Roku says the debug console will generate a warning. The behavior may fail in a future release, no earlier than Roku OS 16.3, according to the current documentation.
That gives developers time to identify and correct affected rendering code before stricter behavior becomes mandatory.
roTextureRequest Adds SetDrawable()
The new SetDrawable() function on roTextureRequest provides more explicit control over whether a returned bitmap can be modified using Roku’s drawing APIs.
By default, non-drawable bitmaps can take advantage of texture caching. When a developer marks a texture as drawable, Roku provides a unique texture-memory copy so it can safely be modified.
This makes the performance trade-off clearer.
If an application only needs to display an image, sharing a cached texture is more memory-efficient.
If the app needs to modify that bitmap dynamically, it can explicitly request drawable behavior.
For developers optimizing applications across Roku devices with different memory capabilities, that distinction can be valuable.
Roku Is Also Preparing Developers for API Deprecations
Roku OS 16.0 includes platform cleanup alongside new features.
method is being deprecated. Roku’s current release notes say Static Analysis will warn developers who still use it, with publishing enforcement planned for April 1, 2027.
Roku points developers toward device-attestation tokens for verifying that messages originated from genuine Roku hardware.
The broader lesson is that teams should not wait until OS 16.0 reaches every consumer before reviewing their applications.
Major OS transitions are also opportunities to identify older APIs that may create publishing or compatibility problems later.
Is Roku OS 16.0 Available to Everyone?
No.
As of September 17, Roku describes OS 16.0 as a beta release being shared with developer beta partners, and Roku’s developer forum explicitly says the operating system remains under NDA until the company begins its release-to-all process.
Roku has not announced a general consumer rollout date in the public preview.
That means ordinary Roku users should not assume their device will immediately update to OS 16 simply because the developer APIs have now been documented.
Developers who want early access can apply through Roku’s beta program and test upcoming functionality before general availability.
What Does Roku OS 16.0 Mean for Streaming Developers?
The biggest theme is flexibility.
SceneGraph developers gain more visual control without relying as heavily on custom image assets. Networked applications gain native tools for real-time communication. BrightScript becomes more forgiving in some areas, while Roku’s graphics APIs become more explicit about errors and texture modification.
These improvements are especially relevant as connected-TV applications become more sophisticated.
Modern streaming apps increasingly resemble full entertainment platforms, with personalized recommendations, live data, rich animations, interactive events, and complex navigation systems.
Roku OS 16.0 gives developers more native building blocks for creating those experiences.
Roku Developer Summit Could Reveal More
The timing of the preview is also worth watching.
Roku’s 2026 Developer Summit takes place September 23–24, less than two weeks after the first public OS 16 API preview.
Roku has already said the event will include major updates to the Roku SceneGraph SDK, developer tools, app performance, monetization, content discovery, and other areas.
That means the current Roku OS 16.0 documentation may only represent part of the development story. Additional tools, workflow improvements, or implementation guidance may become clearer during the summit.
Final Thoughts
Roku OS 16.0 is shaping up to be a significant developer release even though many of its biggest improvements operate behind the scenes.
The new Effect node can make streaming interfaces more modern without forcing developers to build every visual treatment into artwork. ArrayGrid focus customization and array-field animation add further UI flexibility. Meanwhile, native WebSocket and Server-Sent Events support gives Roku applications stronger tools for real-time experiences.
BrightScript improvements, expanded stack depth, clearer graphics success states, and better texture controls should also make complex applications easier to build and debug. The most important detail for now is that Roku OS 16.0 remains a developer beta rather than a public consumer rollout.
With Roku’s Developer Summit scheduled for September 23–24, developers should expect the OS 16 story to continue evolving over the coming days.
FAQs About Roku OS 16.0
1) Is Roku OS 16.0 available now?
Roku OS 16.0 is currently available through Roku’s developer beta process, not as a broad consumer release. Roku says the beta remains under NDA until the company begins its general rollout.
2) What is the biggest new Roku OS 16.0 feature for developers?
One of the largest UI improvements is the new SceneGraph Effect node, which adds GPU-accelerated rounded corners, borders, and gradients to Poster and Rectangle nodes.
3) Does Roku OS 16 support WebSockets?
Yes. The new roWebSocket component allows Roku applications to establish bi-directional WebSocket connections with remote servers.
4) Does Roku OS 16 support Server-Sent Events?
Yes. roUrlTransfer gains Server-Sent Events support and can deliver incoming events to applications as roUrlEvent messages.
5) Can developers customize Roku grid focus indicators?
Yes, OS 16.0 exposes the ArrayGrid focus-indicator poster through focusFeedbackPoster, allowing custom effects and styling to better match content items.
6) Does Roku OS 16 improve BrightScript?
Yes. Roku is relaxing conditional-compilation behavior, increasing maximum stack depth, and changing several drawing APIs to provide Boolean success results.
7) When will Roku OS 16.0 reach all Roku devices?
Roku has not announced a public release-to-all date in the current developer preview. The company is still collecting beta feedback.
Stay Updated with the Player SDK Guide Hub
Roku development is changing quickly, and major OS releases can introduce new APIs, UI capabilities, networking tools, performance requirements, and compatibility considerations for streaming applications. That’s why we created the Player SDK Guide Hub.
The Player SDK Guide Hub covers the latest Roku, Fire TV, Google TV, Android TV, Apple TV, Kodi, Plex, VLC, and streaming-device updates, including operating-system releases, SDK changes, new developer APIs, playback technologies, hardware launches, device specifications, and important platform changes.
Whether Roku expands OS 16.0, introduces new SceneGraph capabilities at Developer Summit, changes app-publishing requirements, or releases another developer tool, our Guide Hub helps explain what changed, why it matters, which devices and applications are affected, and what streaming teams should prepare for next.
Explore the Player SDK Guide Hub for the latest Roku development news, streaming-device updates, technical guides, media-player releases, and connected-TV platform insights.
