Snapchat's Secret React Native Killer

The Bombshell Eight Years in the Making

Eight years after quietly shipping code to hundreds of millions of users, Valdi has finally stepped into the light. Snapchat’s homegrown cross-platform framework, once just an internal experiment to keep Stories smooth on aging Android phones, is now an open-source project promising to upend how “native” apps get built.

At its core, Valdi sells a simple but aggressive pitch: write your app in TypeScript, ship it as truly native code on iOS, Android, and macOSOS. No WebViews, no runtime JavaScript engine, no JSON shuttling across threads. Your JSX-flavored UI compiles down to platform-native views, with layouts driven by Yoga and pixels pushed by Skia.

Traditional cross-platform stacks such as early React Native depended on a JavaScript bridge that passed messages between the JS thread and native layer, often hundreds of times per frame. Every prop update, gesture, or layout change had to cross that boundary, introducing latency, jank, and memory overhead. Valdi sidesteps that entire architecture by erasing the bridge at build time.

Instead of a long-lived JS runtime, Valdi leans on Bazel to orchestrate TypeScript compilation directly into native modules. Layouts use the C++ Yoga engine for consistent Flexbox behavior, while Skia renders high-performance 2D graphics across platforms. The result behaves like a first-class native app: UIKit and AppKit views on Apple platforms, real Android views on Google’s side.

Developer experience aims to match or beat modern React Native and Flutter setups. Valdi supports instant hot reload, so UI tweaks appear in milliseconds, and integrates with VS Code for full debugging, including breakpoints and performance profiling. Snapchat’s own teams have used this loop for years to ship camera, chat, and Discover features without dropping to Swift or Kotlin for every change.

The open-source drop has triggered exactly the reaction you’d expect in 2025: excitement tempered by suspicion. Early adopters praise the “React-but-actually-native” feel and the promise of one TypeScript codebase spanning phones and desktops. Skeptics point to rough edges in the installer, opaque roadmap control by Snapchat, and a blunt question hanging over every GitHub issue: why bet on Valdi when React Native and Flutter already dominate?

A Ghost in the Machine: Why Valdi Was Born

React Native in 2017 looked more like a promising experiment than a foundation for a camera-first social network with 400+ million daily users. Facebook’s framework shipped with no desktop support, immature tooling, and a runtime model that shoved every UI update across a JavaScript bridge running in a separate thread. For companies betting their entire UX on smooth, 60 fps interactions, that bridge was a liability, not a feature.

Every gesture, scroll, and animation in early React Native had to serialize props and events into JSON-like payloads, ship them over the bridge, and then deserialize them on the native side. That marshalling cost translated into jank, dropped frames, and hard-to-debug race conditions. Add a memory-hungry JS runtime on top of native views, and you had two worlds constantly syncing state instead of one coherent app.

Snapchat’s product direction made those trade-offs unacceptable. The app leaned on full-screen video, complex gesture navigation, and ephemeral UI transitions that punished any latency spike. Engineers needed predictable frame times, tight memory ceilings on low-end Android phones, and UI code that behaved like native Swift or Kotlin while still letting feature teams iterate at JavaScript speed.

React Native in that era also skipped entire platform classes Snapchat cared about. There was no credible macOSOS story, no compilation to AppKit views, and no path to reuse the same UI layer across iOS, Android, and an internal desktop client. True concurrency remained theoretical; background work still funneled through a single JS event loop already overloaded with business logic and layout.

So Snap made a strategic call: stop waiting for the ecosystem to grow up. Instead of gambling on React Native’s roadmap, the company invested in Valdi, a TypeScript-first framework that compiled straight to native code and talked to the OS without a bridge. Bazel orchestrated multi-platform builds, Yoga standardized layout, and Skia handled rendering, but the architectural decisions came from Snap’s own performance pain.

That in-house bet let Snapchat optimize for its exact workload—fast camera, infinite scroll feeds, and heavy animations—years before React Native gained Fabric, bridge-less architectures, or serious desktop ambitions.

Under the Hood: Deconstructing Valdi's Engine

Snapchat’s new framework hides a surprisingly industrial engine. Underneath the pastel UI and ghost icon sits a pipeline built around Bazel, Yoga, and Skia—the same kind of heavy macOShinery that powers Google-scale backends and Chrome’s graphics stack. Valdi turns that stack into a front-end factory line for iOS, Android, and macOSOS.

Bazel sits at the center as the build orchestrator. It chews through TypeScript, asset bundles, and native code, then spits out platform-specific binaries with reproducible builds and aggressive caching. That choice lets Valdi scale from a prototype lens picker to a multi-million-line app without drowning engineers in brittle Xcode or Gradle configs.

Layout runs through Yoga, Facebook’s battle-tested Flexbox engine. Rather than reimplementing layout three times, Valdi feeds Yoga a platform-agnostic tree that describes flex properties, margins, and alignment. The same layout math drives UIKit, Android Views, and AppKit, which keeps Snapchat’s UI pixel-consistent across phones, tablets, and desktops.

Rendering leans on Skia, the 2D graphics engine behind Chrome and Android. Valdi can map high-level components to native views or draw directly into Skia surfaces for custom controls, shaders, and animations. That hybrid strategy lets it mix standard buttons with highly bespoke AR-era UI without falling back to web views.

From a developer’s perspective, everything starts as TypeScript classes with JSX. You write something that looks suspiciously like a React component—methods like onCreate and onRender returning JSX tags. Bazel then compiles TypeScript to an intermediate representation, lowers JSX into a view tree, and wires that tree to platform-native view hierarchies.

Ahead-of-time, Valdi generates native bindings for every prop, event, and style. That means no dynamic reflection or JSON shuttling at runtime. Type information flows from TypeScript into Swift, Kotlin, and C++ headers, so the compiler can inline hot paths and strip dead code.

C++ sits at the heart of the layout and diffing engine. Critical paths—tree reconciliation, Yoga calls, Skia draw dispatch—run in C++ on the main thread with minimal marshalling. Instead of serializing props over a bridge, Valdi passes raw pointers and tightly packed structs, cutting per-frame overhead down to microseconds.

Compare that to JavaScript-based runtimes like early React Native. Those stacks pushed layout and logic through a JS bridge, paying a serialization tax every time a button moved or a list scrolled. Valdi’s ahead-of-time model trades runtime flexibility for deterministic performance and far smaller GC pressure.

This architecture looks closer to a game engine than a webview wrapper. Hot reload still works—Bazel and the runtime swap updated TypeScript modules into the native shell—but the final shipping artifact runs with no JavaScript VM at all. For anyone who wants to study the guts, Valdi - Official GitHub Repository exposes the full build graph, C++ core, and TypeScript tooling.

The React Doppelgänger: A Familiar Face

React developers can open a Valdi file and almost forget they switched frameworks. Components look like old-school React class components, with lifecycle-style methods such as `onCreate` and `onRender` instead of `componentDidMount` and `render`. State lives on `this`, methods hang off the class, and UI returns from `onRender` as JSX.

JSX in Valdi does not paint virtual DOM nodes. It compiles straight to native iOS, Android, and macOSOS views, with Yoga driving layout. Developers write Flexbox-style props like `flexDirection`, `justifyContent`, and `alignItems` that feel like CSS, but the pipeline turns them into low-level layout instructions.

A Valdi layout for a feed item might use JSX with props such as `padding`, `margin`, and `borderRadius` on components that map to native views. Under the hood, Yoga calculates positions and sizes identically across platforms, while Skia renders 2D graphics where custom drawing is needed. The result behaves like a React tree but runs like a C++ UI engine.

Snapchat clearly targeted web engineers who already speak TypeScript and JSX. Instead of learning UIKit, Jetpack Compose, and AppKit, developers keep writing components, props, and decorators. That design choice lowers the barrier for JavaScript and front-end teams to ship native features without rewriting their mental model.

Developer experience sits at the center of Valdi’s pitch. Instant hot reload pushes TypeScript changes to a running simulator or device in milliseconds, avoiding full native rebuilds that can take 30–90 seconds in Xcode or Android Studio. State often survives reloads, so tweaking layout or behavior feels closer to editing a web app.

Full VS Code debugging support completes the React doppelgänger act. Engineers set breakpoints in TypeScript, inspect variables, and step through Valdi component logic while the compiled app runs on iOS, Android, or macOSOS, blurring the line between web tooling and native execution.

Native Speed Without Native Pain

Native frameworks obsess over recycling table view cells and composable layouts; Valdi bakes that mentality into every component. Instead of leaving reuse to individual screens, Valdi keeps a global pool of native views that any list, grid, or carousel can grab from and return. That means fewer allocations, less churn in the allocator, and less pressure on the garbage collector on Android.

Automatic view recycling happens at the framework level, not as a pattern you remember to implement. When a component scrolls off-screen, Valdi detaches it, resets its props, and drops it back into the pool. New items pull from that pool, so even a 10,000-item feed reuses a tiny, fixed set of native view instances.

Viewport-aware rendering pushes this further. Valdi tracks which components intersect the visible viewport and only mounts those, plus a small buffer above and below. Anything outside that window pauses updates and can even dehydrate to a lightweight representation.

Infinite scroll feeds become the default, not a performance project. A Snapchat-style Discover rail or Spotlight-style vertical feed can stream unbounded content while touching only a few dozen live views at any time. Combined with Skia rendering, scroll performance approaches 60 fps on mid-range Android hardware without custom tuning.

Independent component render cycles give Valdi another edge. Each component owns its own render loop, so updating a child does not automatically trigger a parent diff, and vice versa. That breaks the “update waterfall” that plagues poorly tuned React and React Native trees.

Valdi’s scheduler can prioritize input-driven updates—like a drag gesture or a text input—over low-priority background re-renders. A chat message bubble animating in does not force the entire conversation list to reconcile. The result: fewer layout passes, fewer measure calls, and a more predictable frame budget.

Against a modern, optimized native app built in SwiftUI or Jetpack Compose, Valdi’s theoretical gains come from three layers at once. It combines: - Global view pooling - Viewport-aware mounting - Decoupled component render cycles

SwiftUI can lazily render lists, and Compose can recycle under the hood, but app teams still re-implement patterns like cell reuse, pagination windows, and throttled updates. Valdi centralizes those decisions in the framework. On paper, that lets a small team ship a cross-platform feed that behaves like a hand-tuned native one—without writing a single custom recycler or diffing algorithm.

The World Moved On: React Native's Revenge

React Native in 2025 barely resembles the framework Snapchat evaluated eight years ago. Meta ripped out the infamous JavaScript bridge, replacing it with a unified C++ core that speaks directly to native views. Latency dropped, memory usage stabilized, and “jank” went from a default assumption to a performance bug.

Fabric, React Native’s modern rendering architecture, did most of that heavy lifting. Instead of batching messages over a bridge, Fabric keeps a single tree for React and native, enabling concurrent rendering and fine-grained prioritization. React 18’s concurrent features now flow straight into mobile UIs, so background updates no longer freeze scroll or touch input.

Under Fabric, layout still leans on Yoga, but with tighter integration. Layout calculations run in C++, shareable across iOS, Android, and Windows, and React Native can precompute or discard work when components exit the viewport. That architecture directly addresses the “no true concurrency” criticism that originally pushed Snapchat toward Valdi.

Microsoft quietly closed one of React Native’s biggest gaps: first-class desktop. React Native macOSOS and React Native Windows now ship as supported products, not side projects. Office, Teams, and Xbox companion apps lean on these stacks, proving React Native can target desktop without resorting to Electron or web views.

Feature parity across platforms now looks surprisingly complete. A single codebase can hit iOS, Android, Windows, and macOSOS using shared components, native menus, and system-level accessibility APIs. Dev teams that once maintained three or four UI stacks routinely consolidate down to one plus a thin layer of platform glue.

Ecosystem maturity might be React Native’s strongest weapon against Valdi. Expo evolved into a batteries-included platform with: - Fast Refresh for near-instant code updates - OTA updates via EAS Update - Prebuilt SDKs for camera, notifications, and sensors

Around that core, a sprawling marketplace of libraries—React Navigation, Reanimated, React Query, Lottie, and more—covers most app needs. Documentation improved, TypeScript support hardened, and companies like Shopify, Coinbase, and Walmart now ship production apps on React Native. For anyone comparing options, Valdi Official Documentation now competes with a juggernaut rather than an experimental toolkit.

A Rocky Start: The Developer Experience Paradox

Installing Valdi today feels less like grabbing a polished SDK and more like joining an internal tools pilot. Officially “beta,” the framework ships with rough edges that surface as soon as you run the first `valdi init`. On macOSOS, you juggle Bazel, Android SDKs, Xcode toolchains, and Node versions before you even see a “Hello, world” screen.

Developers report that Valdi’s installer happily mis-detects or auto-installs the wrong dependency versions. The Better Stack walkthrough hit mismatched Android build tools and TypeScript configs before rendering a single view. For a framework pitching “native speed, web velocity,” this fragile setup undercuts the headline promise.

Early adopters also hit oddly specific landmines. Project names cannot contain hyphens; `my-app` silently breaks where `my_app` works fine, a constraint that feels more like an internal convention than a public product decision. Path assumptions and hard-coded defaults leak out from Snapchat’s monorepo into everyone else’s laptops.

On paper, Valdi sells a premium developer experience: instant hot reload, full VS Code debugging, and cross-platform builds that “just work.” In practice, the beta feels closer to wiring up your own toolchain around a powerful but temperamental engine. You spend as much time appeasing Bazel and Gradle as you do writing JSX.

Documentation exposes the same paradox. Official guides cover the happy path—basic setup, simple views, a few lifecycle hooks—but fall off quickly once you stray into custom native modules, advanced Skia usage, or CI integration. Many edge cases live only in Snapchat’s internal lore or scattered community gists.

Valdi clearly needs more “battle testing” outside Snap’s walls. React Native’s decade of GitHub issues, Stack Overflow answers, and Expo recipes does not exist here yet, and you feel that absence every time an obscure Bazel error blocks your build.

A Giant With No Army

A single framework, no matter how slick, cannot compete with a million-developer head start. Valdi ships with impressive internals, but it ships with almost no ecosystem. No Reddit hive mind, no battle-tested boilerplates, no decade of weird edge cases already answered by someone in Bangalore at 3 a.m.

React Native’s greatest weapon now is not Fabric, Yoga, or Expo; it is gravity. A massive global community produces endless YouTube tutorials, Udemy courses, and Medium posts, plus thousands of open source packages. Corporate backing from Meta, Microsoft, Shopify, and others amplifies that momentum with long-term roadmaps and paid teams fixing bugs that most people will never see.

Search “React Native push notifications” and you drown in options. Search “Valdi push notifications” today and you mostly get Snapchat’s own docs and a few experimental repos. For real-world teams, that difference determines whether a sprint ships on time or stalls while someone reverse-engineers a native bridge.

Developers lean on Stack Overflow as much as on official documentation. With Valdi, there are almost no accepted answers, no canonical snippets, no five-year-old threads explaining why a layout explodes on a specific Android OEM skin. Every problem risks becoming a zero-to-one research project instead of a quick copy-paste from a green checkmark.

Third-party libraries form the scaffolding of modern app development. React Native developers expect: - Navigation stacks with deep-linking baked in - Analytics SDK wrappers for Amplitude, Segment, Mixpanel - Payments, auth, and maps components from Stripe, Auth0, Google, and more

Valdi offers almost none of that today, forcing teams back into custom native integrations and TypeScript bindings for every service they touch.

Single-company frameworks always carry existential risk. If Snapchat’s priorities shift—another redesign, another platform bet—Valdi could quietly stall while its GitHub issues pile up. For a startup choosing a stack in 2025, betting on a framework that effectively has one primary production user feels less like adopting a tool and more like tying your roadmap to someone else’s product strategy.

Why Now? Unpacking Snapchat's Gamble

Eight years of internal use gives Snapchat a rare luxury: battle-tested infrastructure before public scrutiny. Valdi has quietly powered core Snapchat experiences across iOS, Android, and macOSOS, which suggests one motivation is simple: the framework finally crossed a maturity threshold where open sourcing carries more upside than risk.

Releasing now also aligns with a broader industry shift toward TypeScript-first tooling. Valdi leans hard on TypeScript, JSX, decorators, Bazel, Yoga, and Skia, a stack that now looks mainstream rather than experimental, making it easier for outside developers to understand and extend without Snapchat hand-holding.

Theory one: Snapchat waited until Valdi looked like a finished product, not a research project. Eight years of optimizations—global view pooling, automatic view recycling, hot reload measured in milliseconds—let the company present Valdi as a credible alternative in a world where React Native Official Website already advertises Fabric, concurrent rendering, and Yoga-backed layouts.

Theory two: Snapchat wants free help building a modern component ecosystem. Right now Valdi ships with a relatively thin set of production-ready UI primitives compared to React Native’s ocean of community packages, Expo SDKs, and design-system kits from companies like Microsoft and Shopify.

Crowdsourcing that gap makes strategic sense. By open sourcing, Snapchat can nudge agencies, startups, and internal teams at other companies to contribute everything from basic form controls to complex accessibility widgets, all while Snapchat keeps steering the core runtime and layout engine.

Component libraries also age fast. New OS releases, design trends, and accessibility rules demand constant updates across three platforms. Offloading that treadmill to open source contributors lets Snapchat focus on performance and platform integration instead of endlessly re-skinning buttons and carousels.

Theory three: this is a recruiting play dressed as altruism. High-growth consumer apps fight for senior mobile engineers, and a shiny, technically ambitious framework that compiles TypeScript directly to native views sends a clear signal about Snapchat’s engineering culture.

Publishing Valdi’s internals—Bazel pipelines, Yoga usage, Skia rendering paths—functions as a living portfolio piece. Engineers who care about low-level rendering, concurrency, and toolchains now have a reason to read Snapchat’s code, file issues, and eventually answer a recruiter’s email.

The Verdict: Is Valdi Your Next Framework?

Raw speed still sits on Valdi’s side. Compiling TypeScript straight to native views, skipping JavaScript bridges entirely, gives Snapchat-grade feeds and story carousels that stay smooth even under brutal scroll workloads, helped by automatic view recycling and a global view pool. React Native’s Fabric renderer and TurboModules closed much of that gap, but it still routes more logic through a managed runtime and a sprawling abstraction layer.

React Native counters with an ecosystem that Valdi simply does not have. Expo, React Navigation, React Query, Reanimated, and thousands of packages cover everything from authentication to video editing, backed by millions of developers and production apps at Meta, Microsoft, Shopify, and Coinbase. Valdi ships with a lean component set, sparse documentation, and a beta installer that can mis-detect dependencies or choke on something as trivial as a hyphen in a project name.

Teams that should seriously consider Valdi sit at the extreme end of performance and control. If you are building a feed-heavy social app, a high-frequency trading client, or a graphics-dense editor where every dropped frame hurts, Valdi’s Skia-backed rendering and native layouts can justify the pain. You also need a staff that already speaks Bazel, native iOS/Android/macOSOS internals, and can afford to patch a young toolchain instead of filing a GitHub issue and waiting.

Most other teams should stay with React Native. Startups, indie developers, and product teams racing to MVP care more about shipping features than shaving 5–10 ms off layout. React Native’s Expo tooling, Fast Refresh, mature CI templates, and battle-tested libraries reduce risk and hiring friction in a way no 1.0-era framework can match.

Valdi lands in 2025 as a fascinating artifact from a different era of cross-platform angst. Its original mission—bridge-free, high-performance, TypeScript-first UI across iOS, Android, and macOSOS—is no longer unique when React Native, Flutter, and even SwiftUI plus Kotlin Multiplatform crowd the same space. Technically, Valdi proves a small, focused team can out-engineer the status quo; strategically, it may end up a niche weapon for companies whose performance budgets are as aggressive as Snapchat’s.

Frequently Asked Questions

What is Snapchat's Valdi framework?

Valdi is a cross-platform UI framework developed by Snapchat that compiles TypeScript and JSX directly to native code for iOS, Android, and macOS, eliminating the need for a JavaScript bridge.

Why did Snapchat create Valdi instead of using React Native?

Snapchat created Valdi 8 years ago because React Native at the time had performance issues due to its JavaScript bridge, lacked true concurrency, and had no first-class desktop support.

What is the main technical advantage of Valdi?

Valdi's primary advantage is its performance. It compiles directly to native code and uses advanced techniques like automatic view recycling and viewport-aware rendering, which can lead to faster, more efficient apps.

What are the biggest risks of using Valdi for a new project?

The main risks are its lack of a large community, immature documentation, and the uncertainty of long-term support from Snapchat. In contrast, React Native is a mature ecosystem with extensive community backing.