Infinite Red
Maintaining out-of-tree desktop platforms allows Microsoft to deploy unified cross-platform interfaces across modern systems without rewriting decades-old native C++ codebases.
AI-assisted summary of Chiara Mooney & Shiven Mian – Building for Microsoft (Chain React 2023) — original source. Check the original for full context.
Source published:
Key ideas
- Microsoft maintains out-of-tree React Native targets for Windows and macOS, powering production surfaces for over one billion users across products like Windows 11, Office, and Xbox. (3:08)
- React Native for Windows supports both native XAML control mapping via react-native-xaml and JavaScript-styled cross-platform components through Fluent UI React Native. (5:57)
- Rather than full rewrites of legacy 1980s codebases, Microsoft heavily leverages Brownfield integration to embed shared cross-platform, cross-app components like Modern Comments and the Persona card into native Office hosts. (19:24)
- To solve developer velocity and dependency drift, Microsoft open-sourced developer tools including react-native-test-app (RNTA) for platform harness testing and rnx-kit for repository dependency alignment and tree shaking. (25:11)
Detailed notes
## Background Published on YouTube by Infinite Red on June 1, 2023, this talk features Microsoft software engineers Chiara Mooney and Shiven Mian speaking at the Chain React 2023 conference in Portland, Oregon. According to the video description, the session offers an inside look at the journey and technical challenges Microsoft developers face when building, maintaining, and consuming React Native for Windows.
## TL;DR Chiara Mooney and Shiven Mian present how Microsoft leverages out-of-tree platforms—React Native for Windows and React Native macOS—to power production experiences across desktop and mobile reaching over a billion users. They highlight real-world implementations ranging from Greenfield apps like Xbox PC to Brownfield integrations embedded in legacy C++ codebases like Microsoft Office's Modern Comments and the Persona card. The talk covers technical solutions for desktop-specific accessibility, high-contrast theming, and keyboard navigation, as well as Microsoft's suite of open-source developer tools including React Native Test App (RNTA), Fluent UI React Native, and rnx-kit. Ultimately, the speakers encourage mobile engineers to expand their codebases to desktop targets using these established frameworks.
## Atmosphere & style The presentation strikes an approachable, conversational, yet deeply authoritative tone that smoothly bridges framework maintenance with enterprise product delivery. Mooney and Mian establish a warm rapport, engaging the audience with playful visual quizzes of Windows 11 interfaces and lighthearted remarks about working on Office code older than themselves. Watching the talk feels both grounding and inspiring, translating formidable architectural hurdles in enterprise software into accessible, battle-tested patterns for the broader React Native community.
## Bulletin - [03:08](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=188s) Microsoft maintains out-of-tree React Native targets for Windows and macOS, powering production surfaces for over one billion users across products like Windows 11, Office, and Xbox. - [05:57](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=357s) React Native for Windows supports both native XAML control mapping via react-native-xaml and JavaScript-styled cross-platform components through Fluent UI React Native. - [19:24](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1164s) Rather than full rewrites of legacy 1980s codebases, Microsoft heavily leverages Brownfield integration to embed shared cross-platform, cross-app components like Modern Comments and the Persona card into native Office hosts. - [25:11](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1511s) To solve developer velocity and dependency drift, Microsoft open-sourced developer tools including react-native-test-app (RNTA) for platform harness testing and rnx-kit for repository dependency alignment and tree shaking.
## Key takeaways - [00:55](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=55s) React Native for Desktop brings mobile codebases and developer ergonomics to desktop environments via out-of-tree targets maintained by Microsoft. - [03:08](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=188s) Core Windows 11 surfaces—such as the Start menu's Recommended feed and the Settings Accounts page—are built with React Native for Windows with visual parity. - [05:57](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=357s) Maintaining out-of-tree platforms requires continuous engineering to match upstream core API updates and breaking changes while adopting the new Fabric architecture. - [08:39](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=519s) Desktop interfaces demand distinct accessibility engineering compared to mobile, pivoting away from touch-first models toward keyboard tab navigation, mouse inputs, and screen reader trees. - [11:28](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=688s) React Native Windows exposed the AppTheme API to detect operating system high contrast modes and query active high contrast palette tokens like the Dusk theme. - [13:14](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=794s) The open-source React Native Gallery app in the Microsoft Store acts as an interactive testbed and accessibility validation suite for native desktop components. - [16:21](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=981s) All internal React Native deployments at Microsoft must uphold stringent enterprise quality standards across reliability, versioning, localization, performance, security, and native look and feel. - [17:45](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1065s) Architectural deployments fall into Greenfield apps like the Xbox PC app and Brownfield integrations embedded in existing native Win32/C++ shells. - [19:24](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1164s) The Modern Comments feature in Microsoft Office shares a single React Native codebase cross-platform (Windows, macOS, iOS, Android) and cross-app (Word, Excel, PowerPoint). - [22:15](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1335s) The Persona card demonstrates platform-adaptive UX from a shared codebase, using full-screen transitions on mobile while adapting to hover flyouts and modal dialogs on desktop. - [25:11](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1511s) react-native-test-app (RNTA) provides an app shell abstraction that allows developers to test cross-platform Brownfield code without rebuilding monolithic native host apps. - [27:25](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1645s) rnx-kit provides enterprise-scale repository tooling, featuring align-deps to prevent package skew and esbuild integrations for bundle tree shaking. - [29:04](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1744s) Investing in out-of-tree platforms abstracts away low-level native Win32 and C++ platform complexity, enabling product teams to deliver accessible, high-performance experiences reaching over a billion users.
## Detailed walkthrough ### [00:55](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=55s) Introduction to React Native for Desktop
Chiara Mooney opens the session by welcoming the audience to the end of Day 1 at Chain React, introducing herself alongside co-presenter Shiven Mian. Both are software engineers at Microsoft. Mooney works as a maintainer of the React Native for Windows platform, where she concentrates on driving package releases, building accessibility features, and maintaining the Windows source code for the community `react-native-webview` module. She notes that Mian will introduce his work in more detail later in the session.
Setting the stage, Mooney asks developers to consider taking the goodness of React Native—its rich app experiences and developer ergonomics—and applying it beyond mobile to desktop apps. She poses an even more ambitious scenario: bringing existing mobile codebases over to desktop environments with minimal friction. This capability exists through the React Native for Desktop initiative.
```mermaid flowchart TD accTitle: React Native for Desktop Core Targets accDescr: Out-of-tree desktop platform targets maintained in open source by Microsoft.
subgraph DesktopTargets["React Native for Desktop"] RNW["React Native for Windows"] RNM["React Native macOS"] end
Upstream["React Native Core"] -->|"Out-of-tree target"| RNW Upstream -->|"Out-of-tree target"| RNM ```
Mooney lays out three concrete goals that she hopes attendees will remember as they leave the auditorium for the conference mixer: - Developers can build fully functional desktop applications with React Native. - Major, high-visibility Microsoft products are actively running on React Native in production today. - When engineering mobile applications in React Native, teams should think about desktop targets as well.
[03:08](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=188s) React Native for Windows and Production Surface Areas
Surveying the audience, Mooney observes that while many attendees have heard of React Native for Desktop, considerably fewer have actually attempted to use it. She explains the technical structure: React Native for Desktop consists of two primary out-of-tree platform targets—React Native for Windows and React Native macOS. Both are actively maintained in open source by Microsoft engineering teams, offer full API parity with upstream core, and are currently in the process of adopting the new React Native architecture, including Fabric.
Addressing whether React Native for Windows is truly viable for industry-grade, production-scale software, Mooney points to real Windows operating system surfaces. She presents side-by-side screenshots of the Windows 11 Start menu and challenges the audience to spot which UI elements are powered by React Native versus the traditional native Windows tech stack. The integration is visually imperceptible. She reveals that the Start menu's "Recommended" feed is completely rendered via React Native for Windows.
She then demos the Windows Settings application, specifically the Accounts page, which was built entirely with React Native for Windows while preserving the look and feel of Windows 11. Stating Microsoft's commitment directly, Chiara Mooney explains: “Windows is betting on React Native; we're betting on this platform because we're choosing to trust this platform with not only some experiences at Microsoft, but some of our key experiences for our users.”
[05:57](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=357s) Architectural Challenges: Parity, Native Styling, and Community Modules
Building out React Native for Windows came with substantial engineering hurdles. The first was the ongoing task of playing catch-up. Because the desktop project began after React Native was already established, the team had to race toward upstream API parity while continuously tracking new releases, breaking changes, and deprecations from core. The guiding principle was ensuring that all capabilities present in upstream React Native were seamlessly accessible in the Windows ecosystem.
The second core challenge was delivering a pixel-perfect, native Windows look and feel. Microsoft engineers addressed this across the ecosystem through two primary UI strategies:
```mermaid flowchart LR accTitle: React Native UI Integration Approaches on Windows accDescr: Two technical routes for rendering native Windows interfaces in React Native.
subgraph RNXamlApproach["Native Direct Approach"] RNX["react-native-xaml"] -->|"Exposes native controls"| WinUI["Windows XAML Controls"] end
subgraph FluentApproach["Core Styling Approach"] CoreComp["Core Components (View, Text)"] -->|"JS Styling Layer"| FURN["Fluent UI React Native"] end ```
- **`react-native-xaml`**: A community module designed to expose native XAML controls (the standard UI framework used across Windows OS interfaces) directly to React Native developers. This allows both internal teams and external community members to build with first-party Windows UI components. - **Fluent UI React Native (`@fluentui/react-native`)**: An alternative approach that uses React Native's standard cross-platform components (such as `View` and `Text`) and layers JavaScript styling rules over them, delivering controls that mirror Fluent design specifications. - **Cross-Platform Ecosystem Support**: The team also actively contributes Windows implementations back into popular community modules, including `react-native-webview` and various date pickers, ensuring third-party libraries function consistently across platforms.
[08:39](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=519s) Meeting Windows Accessibility and Input Standards
The final architectural hurdle was adhering to Microsoft's strict product quality criteria. All software shipped within Windows must conform to strict standards, and internal engineering teams must be able to deliver fully compliant applications regardless of the UI framework they pick. While Mian will cover the broader quality requirements later in the talk, Mooney dives deep into the accessibility pillar, which she leads.
In mobile React Native, accessibility features are typically modeled around touch-first interactions using properties and APIs like `accessible`, `focusable`, and `setAccessibilityFocus()`. Moving to the desktop environment fundamentally alters the primary input modality, shifting the interaction focus from touch to keyboards, mice, and specialized controllers.
Windows enforces strict accessibility evaluations across screen readers (such as Narrator), full keyboard tab navigation, and high-contrast theme adjustments. To make the framework compliant with these expectations, the team undertook a multi-stage approach: - Delivering complete API parity with React Native's standard core accessibility properties and methods. - Extending the surface by engineering Windows-specific APIs designed to handle specialized desktop needs, including granular keyboard input hooks and desktop mouse interaction models.
[11:28](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=688s) High Contrast Mode and Matching Windows Accessibility Behavior
React Native inherently supports light and dark themes, but the Windows operating system introduces high contrast mode, a critical accessibility feature. Chiara Mooney illustrates this by displaying the Windows Settings Accounts page side-by-side in standard dark mode and in high contrast mode using the Dusk theme. Bringing React Native into core Windows experiences requires absolute visual coherence with native controls, and that visual fidelity must extend to high contrast themes. To achieve this, the team built and exposed an API called `AppTheme`, which enables React Native applications to detect whether the user has enabled high contrast mode and, if so, query the exact high contrast palette colors that the interface should render.
```mermaid flowchart TD accTitle: React Native Windows High Contrast Detection accDescr: Flowchart showing how an application detects Windows theme states and assigns appropriate system colors.
subgraph OSLevel["Windows Operating System"] A["OS Theme Settings\n(Light, Dark, High Contrast)"] B["High Contrast Palettes\n(e.g., Dusk theme)"] end
subgraph RNWBridge["React Native Windows Platform"] C["AppTheme API"] end
subgraph AppLevel["Target Application"] D{"High Contrast Active?"} E["Apply Standard Light/Dark Styling"] F["Query and Apply Active High Contrast Colors"] end
A --> C B --> C C --> D D -->|No| E D -->|Yes| F ```
Beyond theming, delivering robust accessibility required aligning screen reader focus behavior with established Windows operating system norms rather than importing mobile paradigms from iOS or Android. Because screen readers across iOS, Android, Windows, and macOS interact with focus trees differently, Microsoft mapped out these discrepancies internally so external consumers wouldn't have to navigate platform fragmentation alone. As Chiara emphasizes:
> “The big takeaway from all this information is that we've done the research on accessibility so that you don't have to.”
- **The `AppTheme` API** allows JavaScript code to programmatically detect high contrast state and fetch specific system brush tokens. - **Platform-specific focus trees** ensure keyboard and screen reader focus progression aligns with desktop accessibility expectations instead of touch-first mobile mechanics.
---
[13:14](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=794s) Developer Guidance, Gallery Validation, and Production Proof
Equipping the core platform with accessibility capabilities is only part of the equation; guiding product engineers to adopt those APIs is equally critical. The team prioritized clear messaging and developer documentation so teams building internal and external applications understand precisely how and when to invoke React Native accessibility APIs. To maintain accessibility across continuous framework updates, the team relies on the React Native Gallery app—an open-source application available in the Microsoft Store that demonstrates supported components, interactive samples, and native controls. The Gallery app undergoes regular accessibility validation to guarantee that components remain compliant and deliver a polished end-user experience.
Multiple prominent Microsoft products validate these investments in production today. In addition to the Windows 11 Start Menu and the Windows Settings Accounts page, the Xbox PC app is written entirely in React Native Windows. In live usage, the Xbox PC app demonstrates complete high contrast theming and seamless full-keyboard navigation. While the presentation emphasizes Windows, Chiara notes that the React Native macOS team has undertaken parallel platform work to provide out-of-the-box accessibility aligned with macOS conventions.
- **React Native Gallery** serves as an interactive catalog in the Microsoft Store showcasing fully accessible React Native Windows controls. - **Xbox PC App** proves that full Greenfield, desktop-first applications can achieve accessibility parity using React Native. - **React Native macOS** implements matching OS-level accessibility adaptations tailored to Apple desktop conventions.
---
[16:21](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=981s) Handover to Shiven Mian and Microsoft's Production Quality Standards
Chiara introduces Shiven Mian, a software engineer within Microsoft's Office Product Group whose work centers on React Native Android and JavaScript runtime architecture. Maintaining out-of-tree React Native platforms like React Native Windows and React Native macOS introduces distinct engineering overhead. Because Microsoft relies heavily on these frameworks to power primary experiences inside flagship software, platform implementations must satisfy rigorous operational standards before shipping. Shiven explains:
> “So we ensure that these quality standards are upheld within the platform itself so that you don't have to worry about them and you can focus more on doing your best work.”
Adoption across internal product groups and the broader open-source ecosystem rests entirely on React Native satisfying these baseline requirements without compromising performance or stability.
| Quality Standard | Focus and Impact | |:--- |:--- | | **Reliability** | Eliminating crashes and resource leaks within long-running desktop and mobile processes. | | **Version Support** | Maintaining upgrades and backward compatibility across fast-moving React Native releases. | | **Localization** | Seamlessly handling diverse languages, text bidirectionalities, and regional string layouts. | | **Performance** | Fast startup, low memory footprint, and high-framerate rendering across low- and high-end devices. | | **Security & Privacy** | Fulfilling strict corporate compliance, sandbox constraints, and enterprise security policies. | | **Native Look & Feel** | Adhering faithfully to each host OS's human interface guidelines and design tokens. |
---
[17:45](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1065s) Scale, Greenfield Development, and Brownfield Modern Comments
Microsoft deploys React and React Native experiences to billions of active users across four primary client platforms: Windows, macOS, iOS, and Android. Products leveraging these technologies include Microsoft Office, Outlook, Microsoft Teams, the Windows operating system itself, Power Apps, and Xbox. These products represent radically divergent application architectures that vary based on when they were conceived, what problems they solve, and how they integrate React Native:
- **Greenfield Applications:** Built from scratch entirely in React Native. The Xbox PC app serves as a prime desktop example, rendering its entire shell and interface through React Native Windows. - **Brownfield Applications:** Large, pre-existing native host applications that embed distinct React Native experiences within isolated sub-panes or views.
```mermaid flowchart LR accTitle: Modern Comments Brownfield Architecture accDescr: Diagram illustrating a shared React Native codebase embedded within different native Office host applications.
subgraph SharedCode["Shared React Native Codebase"] MC["Modern Comments Feature"] end
subgraph NativeHosts["C++ / Native Office Applications"] Word["Microsoft Word\n(Desktop & Mobile)"] Excel["Microsoft Excel\n(Desktop & Mobile)"] PPT["Microsoft PowerPoint\n(Desktop & Mobile)"] end
MC -->|"Embedded Host Pane"| Word MC -->|"Embedded Host Pane"| Excel MC -->|"Embedded Host Pane"| PPT ```
The canonical example of Microsoft's Brownfield model is "Modern Comments" in Microsoft Office. In Microsoft Word on Windows, the modern commenting pane does not run as a native Win32/C++ control; it is an embedded React Native surface running inside a dedicated pane hosted by the non-React Native container. This same architectural pattern is leveraged across desktop and mobile versions of Office.
---
[19:24](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1164s) Overcoming Legacy Codebases, Cross-App Code Sharing, and UX Cohesion
Adopting React Native across large enterprise applications presents deep architectural hurdles. Core applications like Office and Windows feature some of the largest, oldest codebases in the technology industry, encompassing hundreds of millions of lines of production code written predominantly in C++ and C#. Shiven points out the stark reality of rewriting these systems:
> “As a matter of fact, Microsoft Office still has code from the 1980s in production, which which also means it's older than me.”
Given decades of accumulated native logic, rewriting these monolithic systems as Greenfield React Native apps is impossible. Instead, the Brownfield model allows modern React Native components to coexist inside legacy hosts. To maximize return on engineering investment, Microsoft designs these experiences to be both cross-platform and "cross-app." The Modern Comments engine is a unified codebase that runs across Microsoft Word, Microsoft Excel, and Microsoft PowerPoint across Windows, macOS, iOS, and Android.
Achieving this requires balancing three core technical tensions:
1. **Maximizing Code Sharing:** Enabling engineers to write feature logic once in a central repository that behaves predictably across four native targets. 2. **Preserving Native Platform Ergonomics:** Honoring distinct mobile and desktop design languages so controls do not feel like foreign web wrappers or mobile ports on desktop environments. 3. **Optimizing Developer Experience:** Establishing validation workflows so feature developers working primarily in JavaScript can test, iterate, and ship desktop functionality without requiring deep native domain expertise in C++, Win32, or macOS Cocoa APIs.
[22:15](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1335s) Case Study: The Cross-Platform Persona Card in Microsoft Office
To demonstrate the real-world power and flexibility of React Native, the presentation shifts to one of Microsoft’s most widely deployed experiences: the Persona card. Embedded directly inside Microsoft Office applications, the Persona card surfaces critical account details, organizational hierarchy, and recent user activity such as edited files and emails. Running a live demo of the Microsoft Word Android application, the speaker shows how tapping the user profile in the top-left corner pulls up this full-screen experience smoothly, delivering native-level responsiveness that feels completely at home on Android while operating as a React Native component embedded inside a massive legacy native host.
```mermaid flowchart TD accTitle: Persona Card Architecture accDescr: Diagram showing how a single React Native codebase powers the Persona Card across Office apps on mobile and desktop platforms with targeted UI adaptations.
subgraph Core["Shared Codebase"] RN["React Native Shared Logic<br/>• Account & Org details<br/>• Recent file/email activity"] end
subgraph Mobile["Mobile Platforms (Full-Screen)"] AND["Android<br/>• Custom back button<br/>• Tailored org button"] IOS["iOS<br/>• Native chevron arrow<br/>• Platform transitions"] end
subgraph Desktop["Desktop Platforms (Hover / Modal)"] WIN["Windows<br/>• Hover flyout & modal<br/>• Text button style"] MAC["macOS<br/>• Natural rounded corners<br/>• Hover flyout & modal"] end
RN --> Mobile RN --> Desktop ```
The Persona card runs across four primary operating systems—Windows, macOS, iOS, and Android—and across products including Word, Excel, PowerPoint, Teams, Outlook, SharePoint, and OneNote. While the core codebase is unified, subtle UI adaptations respect the conventions of each target environment. On mobile screens (iOS and Android), the view defaults to full screen, whereas desktop platforms (Windows and macOS) implement a lightweight hover flyout with an expand button that elevates the card into a full modal view—itself implemented in React Native. Corner radii on macOS naturally mirror Apple's aesthetic, Android and iOS utilize distinct native back-button behaviors, and the "show organization" CTA shifts from a chevron arrow on Apple platforms to plain text on Windows. As the speaker emphasizes:
> “And even though we have these subtle design customizations to make the experience look native, majority of the code here is shared across the platforms and that is why it was so compelling for us to use React Native and actively maintain React Native for desktop.”
- **Applications running Persona card:** Microsoft Word, Excel, PowerPoint, Teams, Outlook, SharePoint, and OneNote. - **Shared architecture:** A single codebase allows feature teams to learn only React Native while deploying across mobile and desktop. - **Platform-tailored interactions:** Hover popovers and modal windows for desktop; dedicated full-screen transitions and platform-authentic navigation controls for mobile.
---
[25:11](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1511s) Solving Cross-Platform Testing with React Native Test App (RNTA)
Building and testing cross-platform features inside enterprise-scale, Brownfield codebases presents significant engineering friction. In an ecosystem as vast as Microsoft Office, having to build the entire native application suite just to validate a minor JavaScript tweak is unfeasible. Furthermore, whenever developers attempt to update React Native versions or add support for a new operating system, modifying platform-specific native files risks breakage and demands niche platform domain expertise. Maintaining distinct, bespoke test harness apps for every Brownfield experience rapidly becomes an unsustainable operational burden.
To solve this, Microsoft invested heavily in `react-native-test-app` (known colloquially as RNTA). RNTA functions as "platform as a package," providing ready-to-run test harnesses for Windows, macOS, iOS, and Android. It acts as an ultra-thin abstraction layer that encapsulates and centralizes the platform-level hosting logic, effectively serving as an app shell so engineers can iterate purely within JavaScript or TypeScript without touching native build configurations, unless custom native code is specifically required.
> “Testing on multiple platforms is as simple as adding a dependency to React Native, React Native Windows, or React Native macOS in the rnta package.json or we have a CLI in which you can also pick what platforms you want to test on.”
- **Frictionless configuration:** Target platforms can be added simply by adding dependencies to `package.json` or by generating configurations using the RNTA CLI. - **Broad version matrix:** Enables developers to easily switch and validate their components against older or newer React Native versions. - **Community availability:** Fully open-sourced and hosted within the Microsoft React Native GitHub repositories with extensive documentation and prior conference talks detailing its mechanics.
---
[27:25](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1645s) Developer Tooling: Fluent UI React Native and rnx-kit
Beyond test execution harnesses, the speakers detail two critical internal tools that Microsoft has open-sourced to elevate developer velocity across the ecosystem. The first is Fluent UI React Native (FURN), a cross-platform UI component library constructed around Microsoft's Fluent Design System. FURN delivers platform-adaptive design tokens, robust theming, and baked-in accessibility features directly out of the box, seamlessly integrating with stock React Native primitives to create native-feeling experiences with high rendering performance.
The second major pillar is `rnx-kit`, an open-source suite of production-grade developer tooling designed specifically for scaling React Native repositories. Among its capabilities, `rnx-kit` includes `align-deps` to eliminate package version mismatches and dependency skew, built-in TypeScript verification tools, and esbuild-powered tree shaking to shrink JavaScript bundle footprints. Both toolsets are dogfooded across Microsoft's flagship apps to ship software to hundreds of millions of daily active users.
> “Both Fluent UI React Native and rnx-kit are tools that we use internally to build our applications and we use them to ship apps to millions of people.”
- **Fluent UI React Native (FURN):** Provides accessible, theme-driven components mapped directly to Microsoft's Fluent Design specifications. - **rnx-kit:** Offers enterprise-grade repository orchestration tools, available at `aka.ms/rnx-kit`. - **`align-deps`:** Automatically reconciles and enforces consistent, compatible dependency versions across multi-package repositories. - **Optimization:** Provides fast JavaScript tree shaking integrated directly with esbuild.
---
[29:04](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1744s) Conclusion: React Native Desktop at Scale and Upcoming Talks
Wrapping up the presentation, the speakers provide the core takeaways for attendees to take back to their teams on Monday. Building and maintaining out-of-tree platforms like React Native Windows and React Native macOS is demanding, but the investment unlocks immense cross-platform scale and monetizable reach while preserving strict quality, security, and accessibility standards. Crucially, the platform layer insulates product developers from requiring low-level C++ or platform-specific WinUI knowledge, allowing them to remain focused on core user experiences whether migrating a native Greenfield project to desktop or embedding Brownfield cross-platform modules.
> “React Native Desktop today powers experiences in Microsoft reaching a billion users and we know firsthand the challenges that come when working with multiple Brownfield experiences and making it work at scale.”
The speakers acknowledge that out-of-tree platforms are an evolving effort and encourage the community to contribute bug reports, feedback, and pull requests via GitHub and Discord. They also point to key related sessions: Lorenzo Sciandra’s opening talk the following morning titled "The Work That You Don't See," detailing infrastructure work landing inside React Native core; Saad’s App.js talk covering React Native macOS in depth; and Christoph’s upcoming Chain React presentation detailing Meta’s migration of Messenger Desktop from Electron to React Native.
- **Scale reached:** Over one billion users interact with React Native-powered desktop and mobile surfaces inside Microsoft products. - **Central resource hub:** Documentation, talk recordings, and platform guides are maintained at `aka.ms/react-native`. - **Recommended talks:** - Lorenzo Sciandra on React Native Core maintenance ("The Work That You Don't See"). - Saad on React Native macOS (available on YouTube from App.js). - Christoph on Meta’s migration of the Messenger desktop app from Electron to React Native.
[32:42](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=1962s) Closing Remarks and Acknowledgments
Wrapping up the presentation, the speakers emphasize how much they rely on and appreciate the broader developer community as they continue developing and refining their tools. They issue an open invitation to the audience to get involved, noting that whether developers are building apps or extending the framework itself, external input remains critical to their roadmap: “we really value contributions and feedback to all of these platforms”.
They conclude by expressing their gratitude to the Chain React organizers at Infinite Red for putting together the event and inviting them to speak. They also give a shout-out to Ken for the introduction earlier in the session, before thanking the audience for their time and wishing everyone a good evening as the talk comes to an end.
## Notable quotes > [03:08](https://www.youtube.com/watch?v=kMJNEFHj8b8&t=188s) Windows is betting on React Native; we're betting on this platform because we're choosing to trust this platform with not only some experiences at Microsoft, but some of our key experiences for our users. — Chiara Mooney
## Mentioned Chiara Mooney, Shiven Mian, Infinite Red, Meta, Amazon, Expo, Microsoft, React Native, React Native for Windows, React Native macOS, Fabric, Windows 11, Start menu, Windows Settings, react-native-xaml, WinUI, Fluent UI React Native, react-native-webview, Narrator, AppTheme, React Native Gallery, Microsoft Store, Xbox PC app, Microsoft Office, Outlook, Microsoft Teams, Power Apps, Modern Comments, Microsoft Word, Microsoft Excel, Microsoft PowerPoint, Persona card, SharePoint, OneNote, react-native-test-app (RNTA), rnx-kit, align-deps, esbuild, Lorenzo Sciandra, Saad, Christoph, Messenger Desktop, Electron
## Video description Chiara Mooney & Shiven Mian, Microsoft An inside look at the journey and challenges of building and consuming React Native Windows by Microsoft developers.
Slides from the talk: https://microsoft-my.sharepoint-df.com/:b:/p/chiaramooney/EfQD-GUSP-9ArEHGi-Zh0NIBs_ZVxDRGCVpuqsNpntvTVg?e=f9lHOy
Chain React 2023 Chain React is a three-day event in Portland, Oregon exploring the latest in React Native. Leaders from companies like Meta, Amazon, and Expo all send their developers to Chain React to announce the latest news, make lifelong connections, and advance the industry.
Chain React is hosted by the team at Infinite Red.
Follow Chain React • Website: https://chainreactconf.com • Twitter: https://twitter.com/ChainReactConf • GitHub: https://github.com/infinitered/ChainReactApp2023
Connect with Infinite Red • Website: https://infinite.red
[Source](https://www.youtube.com/watch?v=kMJNEFHj8b8)