ONE PRODUCT SYSTEM · EVERY SCREEN
Hosanna gives product teams one TypeScript architecture for Roku, web, mobile and TV—complete with focus, collections, playback, configuration, native access and tools that can prove what ships.
MODERN TYPESCRIPT · NATIVE ROKU
Write a familiar declarative application model in TypeScript. Hosanna produces the BrightScript and SceneGraph Roku expects while keeping the generated result traceable and the native platform within reach.
@view('HomeScreen') export class HomeScreenView extends BaseView<HomeScreenState> { @state private dataSource = new CollectionViewDataSource([]); protected override getViews() { return [ CollectionView({ id: 'home' }) .dataSource(this.dataSource) .isInitialFocus() ]; } }
Target-aware compiler and lint diagnostics catch unsupported or expensive patterns before the device does.
Source maps connect generated Roku code, stack traces and editor navigation back to the TypeScript you own.
The shipped Roku app is native SceneGraph—not a web view—and direct platform access remains available when it matters.
A COMPLETE LEAN-BACK SDK
Collections, focus, navigation, playback and lifecycle arrive as coherent product systems, so teams can spend their time on the experience viewers will notice.
CollectionView builds full rails, grids and mixed pages from data and configuration, with virtualization, remote loading and incremental updates.
Focus strategies, memory and restoration make ten-foot navigation deliberate rather than a trail of one-off fixes.
Playback, EPG, dialogs, keyboards, overlays, accessibility and deep links belong to the same application model.
SHARED PRODUCT · NATIVE CAPABILITIES
Hosanna reduces duplicate engineering without pretending every device is the same. Renderers, input adapters and typed bridges turn one product model into the right experience on each screen.
Roku, web, iPhone, iPad, Android, Apple TV and Android TV share views, state, services and product intent.
Remote, pointer, touch, keyboard and gamepad input stay device-appropriate without fragmenting the application architecture.
Playback, casting, auth, purchases, notifications, storage, lifecycle and native sheets remain explicit platform capabilities.
A CONFIGURABLE PRODUCT LAYER
Themes, view fragments, translations, assets and platform variants live in a resolvable product layer, while TypeScript owns the behaviour that deserves code.
{
"theme": {
"colors": {
"accent": "#9C5EEF",
"focus": "#BF92FF"
}
},
"translations": {
"en": { "home": "Home" },
"ar": { "home": "الرئيسية" }
},
"locales": {
"ar": { "readingDirection": "rtl" }
}
}
Design tokens, reusable fragments and style inheritance keep rebrands and visual variants coherent.
Locale switching, translation bundles, RTL direction and logical layout values work together across the experience.
Layered build configuration and versioned asset bundles support brands, markets, targets and release stages without duplicating the app.
DEVELOP · INSPECT · VERIFY
Hosanna DevTools connects what appears on screen to the view, state, focus path, service and target-native node that produced it.
Inspect and highlight views, CollectionView cells and SceneGraph nodes while the product runs on a connected target.
Build, deploy, drive input, read logs, capture screenshots and resolve mapped failures without changing mental context.
Turn the finding into a deterministic cross-target test with screenshots, state and reports another engineer can understand.
AI-OPERABLE BY DESIGN
Hosanna connects capable agents to the running application, its framework state and real target devices. They can investigate behaviour, make a change, rerun the scenario and keep the proof.
Reproduce → inspect → edit → run → prove. One complete ticket loop grounded in the real product.
Agents can navigate screens and inspect views, focus, collections, services, native nodes, screenshots and logs.
The result is ordinary TypeScript, a deterministic regression test and reviewable evidence your team retains.
HUMAN SUPPORT · BUILT INTO THE FRAMEWORK
Submit a compiler or framework issue through the Hosanna request form. A Hosanna engineer takes it through reproduction, diagnosis, fix and verification.
Human-in-the-loop support covers both the TypeScript-to-Roku compiler and the Hosanna UI framework.
Your report enters the same inspect, fix, regression and proof loop used to develop the platform.
The fix comes back with targeted regression coverage so the issue stays resolved.
Explore Hosanna with your team, or bring Tantawowa in to deliver the outcome with you.