> For AI agents: the complete documentation index is available at /next/llms.txt, the full documentation bundle is available at /next/llms-full.txt.

# Announcing lynx-ui

[← All Posts](/next/blog/)

May 22, 2026

![Zhou Fang](https://github.com/fzx2666-fz.png)Zhou FangEngineering @ Lynx![Ryan Wang](https://github.com/f0rdream.png)Ryan WangEngineering @ Lynx![Adrian Luo](https://github.com/AdrianLCA.png)Adrian LuoEngineering @ Lynx![MoonfaceX](https://github.com/MoonfaceX.png)MoonfaceXComponent Lead @ Lynx![Guangyu Du](https://github.com/Dugyu.png)Guangyu DuDesign Engineering @ Lynx![Xuan Huang](https://github.com/huxpro.png)Xuan HuangArchitect @ Lynx

[lynx-ui](https://github.com/lynx-family/lynx-ui) has been quietly open-sourced since we gave an early preview at [React Advanced London](https://reactadvanced.com/) last December. After months of polishing components, building the documentation site, and adding examples, today we are excited to announce it as generally available.



lynx-ui components at a glance

## Native Foundations, Web Velocity

[Built-in elements](/next/guide/ui/elements-components.md#built-in-elements) and [XElement](/next/guide/ui/elements-components.md#xelement) give Lynx the low-level capabilities that matter: fast scrolling, precise gestures, and [native rendering](/next/guide/ui/elements-components.md#behind-the-elements-native-rendering). But products are not built from atoms alone. That is where [components](/next/guide/ui/elements-components.md#components-composition-of-elements) belong. At Lynx, native provides the foundation; the web-inspired frontend stack provides the extension layer for composition, state, styling, and product-specific behavior.

lynx-ui delivers on this layering principle: **preserve native user experience, deliver the velocity of the web.**


**This is an example below: lynx-ui-scroll-view**

**Bundle:** `dist/ScrollViewBasic.lynx.bundle` | Web: `dist/ScrollViewBasic.web.bundle`

```tsx {17-28}
// Copyright 2026 The Lynx Authors. All rights reserved.
// Licensed under the Apache License Version 2.0 that can be found in the
// LICENSE file in the root directory of this source tree.

import { root } from '@lynx-js/react'

import { ScrollView } from '@lynx-js/lynx-ui'

import { CircleCard } from '../shared/CircleCard'
import './index.css'

const LETTERS = ['L', 'Y', 'N', 'X', 'U', 'I', 'L', 'Y', 'N', 'X', 'J', 'S']

function App() {
  return (
    <view className='demo-container lunaris-dark'>
      <ScrollView scrollOrientation='horizontal' className='scroll-view'>
        <view className='scroll-view-content'>
          {LETTERS.map((letter, i) => (
            <CircleCard
              letter={letter}
              title='ScrollView'
              subtitle='@lynx-js/lynx-ui'
              key={`circle-${i}`}
            />
          ))}
        </view>
      </ScrollView>
    </view>
  )
}

root.render(<App />)

export default App

```




lynx-ui's [<code>ScrollView</code>](/next/ui/components/scroll-view.md) is built on
top of the native [<code>\<scroll-view></code>
](/next/api/elements/built-in/scroll-view.md) primitive

## Composable Primitives

Encapsulation can become a trap. lynx-ui does not treat components as black boxes with endlessly growing prop surfaces. Instead, it is an [unstyled](/next/ui/styling-theming.md) component library where each component is a **primitive** that handles behavior and state, but ships with no visual design. A primitive is composed of **parts** that you render and style independently.

[`Popover`](/next/ui/components/popover.md) shows the idea. It is not a single opaque component, but a composition of parts with separate responsibilities: `PopoverRoot` owns state, `PopoverTrigger` defines intent, `PopoverPositioner` handles placement, and `PopoverContent` stays structurally independent.


**This is an example below: lynx-ui-popover**

**Bundle:** `dist/PopoverBasic.lynx.bundle` | Web: `dist/PopoverBasic.web.bundle`

```tsx {20-38}
// Copyright 2026 The Lynx Authors. All rights reserved.
// Licensed under the Apache License Version 2.0 that can be found in the
// LICENSE file in the root directory of this source tree.

import { root } from '@lynx-js/react'

import {
  PopoverContent,
  PopoverPositioner,
  PopoverRoot,
  PopoverTrigger,
} from '@lynx-js/lynx-ui'

import { EllipsisIcon, OptionsMenu } from '../shared/index.js'
import './index.css'

function App() {
  return (
    <view className='demo-container lunaris-dark'>
      <PopoverRoot
        defaultShow={true}
        onClose={() => console.info('dismissed!')}
        onOpen={() => console.info('shown!')}
      >
        <PopoverTrigger className='popover-trigger'>
          <EllipsisIcon />
          <PopoverPositioner
            placement='bottom'
            placementOffset={12}
            autoAdjust='shift'
            className='popover-positioner'
          >
            <PopoverContent className='popover-content'>
              <OptionsMenu />
            </PopoverContent>
          </PopoverPositioner>
        </PopoverTrigger>
      </PopoverRoot>
    </view>
  )
}

root.render(<App />)

export default App

```




Composition is all you need.

Because primitives are unstyled, the same composable model creates a foundation for design systems. You can define your own themes through the [styling and theming](/next/ui/styling-theming.md) system, or follow the [shadcn/ui](https://ui.shadcn.com/) pattern to compose themed wrappers on top of the primitives.

### LUNA

[LUNA](/next/ui/luna-themes-tokens.md) is a reference design language we built on top of that foundation.

It grows from Lynx's signature gradient, adapting the brand expression into a softer palette for UI: warm pinks and rose tones moving into lavender and aqua. In LUNA, gradients act as first-class visual materials for expressing form and movement, giving components a sense of changing mediums. That sensitivity also carries into token names: LUNA describes how surfaces are felt, not where they are placed. `ambient` dissolves into the background, `faint` sits near the threshold of perception, `veil` and `film` create soft translucent layers.



L.U.N.A Studio

## Programmable Interaction

Components built around continuous input need two things at once: highly customizable behavior and low-latency response. A swipe, drag, or snap is judged frame by frame. If the visual response trails behind the gesture, the component may still work, but it no longer feels native.

Lynx's [dual-thread model](/next/blog/lynx-unlock-native-for-more.md#use-the-main-thread-responsibly-for-interactivity) defaults JavaScript to the background thread, keeping the main thread free for rendering. But [Main-Thread Script](/next/react/main-thread-script.md) can move interaction logic onto the main thread when it matters, making per-frame behavior fully programmable without crossing a thread boundary. [`Swiper`](/next/ui/components/swiper.md) shows the idea directly: drag input feeds transform updates frame by frame, so the card follows the gesture instead of catching up to it later.


**This is an example below: lynx-ui-swiper**

**Bundle:** `dist/SwiperCustomTinder.lynx.bundle` | Web: `dist/SwiperCustomTinder.web.bundle`

```tsx {22-36}
// Copyright 2026 The Lynx Authors. All rights reserved.
// Licensed under the Apache License Version 2.0 that can be found in the
// LICENSE file in the root directory of this source tree.

import { root } from '@lynx-js/react'

import {
  Swiper,
  SwiperItem,
  interpolate,
  interpolateJS,
} from '@lynx-js/lynx-ui'

import { Card } from './Card'

import './styles.css'

const itemArr: number[] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
const ITEM_WIDTH = 220
const ITEM_HEIGHT = 330

const customAnimation = (value: number) => {
  'main thread'
  const translateX = interpolate(value, [-1, 0], [-ITEM_WIDTH, 0], 'clamp')
  const translateY = interpolate(value, [0, 1], [0, -18], 'extend')
  const rotate = interpolate(value, [-1, 0], [-15, 0], 'clamp')
  const scale = interpolate(value, [0, 1], [1, 0.95], 'extend')
  const opacity = interpolate(value, [-1, -0.8, 0, 1], [0, 0.9, 1, 1], 'clamp')

  return {
    transform:
      `translate(${translateX}px, ${translateY}px) rotateZ(${rotate}deg) scale(${scale})`,
    opacity: opacity,
    'transform-origin': 'center',
  }
}

const customAnimationFirstScreen = (value: number, _index: number) => {
  const translateX = interpolateJS(value, [-1, 0], [-ITEM_WIDTH, 0], 'clamp')
  const translateY = interpolateJS(value, [0, 1], [0, -18], 'extend')
  const rotate = interpolateJS(value, [-1, 0], [-15, 0], 'clamp')
  const zIndex = interpolateJS(
    value,
    itemArr.map((_, index) => index),
    itemArr.map((_, index) => (itemArr.length - index) * 10),
    'extend',
  )

  const scale = interpolateJS(
    value,
    [0, 1, 0],
    [1, 0.95, 1],
    'extend',
  )
  const opacity = interpolateJS(
    value,
    [-1, -0.8, 0, 1],
    [0, 0.9, 1, 1],
    'clamp',
  )

  return {
    transform:
      `translate(${translateX}px, ${translateY}px) rotateZ(${rotate}deg) scale(${scale})`,
    opacity: opacity,
    'transform-origin': 'center',
    zIndex: zIndex,
  }
}

function SwiperEntry() {
  return (
    <view className='demo-container lunaris-dark'>
      <Swiper
        data={itemArr}
        itemWidth={ITEM_WIDTH}
        itemHeight={ITEM_HEIGHT}
        containerWidth={ITEM_WIDTH}
        duration={500}
        initialIndex={0}
        mode='custom'
        main-thread:customAnimation={customAnimation}
        customAnimationFirstScreen={customAnimationFirstScreen}
        style={{
          overflow: 'visible',
        }}
      >
        {({ index }) => (
          <SwiperItem>
            <view
              class='block-view'
              style={{
                width: '100%',
                height: '100%',
                display: 'flex',
                justifyContent: 'center',
                alignItems: 'center',
              }}
            >
              <Card index={index} />
            </view>
          </SwiperItem>
        )}
      </Swiper>
    </view>
  )
}

root.render(<SwiperEntry />)

export default SwiperEntry

```




A <code>'main thread'</code> function passed to{' '}
<code>main-thread:customAnimation</code> runs per-frame logic on the main
thread

With native foundations and programmable interaction in place, motion becomes practical, not just decorative.

### Motion

[Motion](https://motion.dev/) is one of the most popular animation libraries in the Web community, supporting both spring-based and bezier-based transitions. Thanks to the programmability that [Main-Thread Script](/next/react/main-thread-script.md) brings, we adapted Motion for Lynx as [`@lynx-js/motion`](/next/ui/motion.md), a thin layer that reuses Motion's source directly, and ship an experimental version together with lynx-ui. If you know Motion on the web, you already know how to use it in Lynx.

[`Sheet`](/next/ui/components/sheet.md) shows why that matters. Drag, resistance, release, and settling need to read as one continuous behavior. With [Main-Thread Script](/next/react/main-thread-script.md) keeping interaction close to rendering and Motion defining how the surface moves, the sheet feels held, not just played back.


**This is an example below: lynx-ui-sheet**

**Bundle:** `dist/SheetBasic.lynx.bundle` | Web: `dist/SheetBasic.web.bundle`

```tsx {30-43}
// Copyright 2026 The Lynx Authors. All rights reserved.
// Licensed under the Apache License Version 2.0 that can be found in the
// LICENSE file in the root directory of this source tree.
import { root, useRef } from '@lynx-js/react'

import {
  SheetBackdrop,
  SheetContent,
  SheetHandle,
  SheetRoot,
  SheetView,
} from '@lynx-js/lynx-ui'
import type { SheetRootRef } from '@lynx-js/lynx-ui'

import { ActionButton, TriggerButton } from '../shared/index.js'
import './index.css'

const snapPoints = ['50%']

function App() {
  const sheetRef = useRef<SheetRootRef>(null)

  return (
    <view className='demo-container lunaris-dark'>
      <text className='title-text'>Basic Sheet</text>
      <TriggerButton
        onClick={() => sheetRef.current?.open()}
        text='Open Sheet'
      />
      <SheetRoot
        ref={sheetRef}
        snapPoints={snapPoints}
        initialSnap={0}
        onOpen={() => console.log('Sheet opened')}
        onClose={() => console.log('Sheet closed')}
      >
        <SheetView className='sheet-viewport'>
          <SheetBackdrop className='sheet-overlay' clickToClose={true} />
          <SheetContent
            className='sheet-content'
            innerClassName='sheet-inner-content'
          >
            <SheetHandle className='sheet-handle' />
            <view className='control-panel'>
              <text className='header-text'>Basic Sheet</text>
              <text className='info-text'>
                Simple uncontrolled sheet. Drag or tap backdrop to dismiss.
              </text>
              <ActionButton
                onClick={() => sheetRef.current?.close()}
                text='Close'
              />
            </view>
          </SheetContent>
        </SheetView>
      </SheetRoot>
    </view>
  )
}

root.render(<App />)

export default App

```




<code>Sheet</code> uses <code>@lynx-js/motion</code> under the hood for
spring-driven drag and settle transitions

## Try it today

lynx-ui is available on iOS, Android, and HarmonyOS today, with partial Web and Desktop support on the horizon. Read the [introduction](/next/ui/index.md) to get oriented, or jump straight to the [quick start](/next/ui/introduction.md#quick-start) to install [`@lynx-js/lynx-ui-*`](https://www.npmjs.com/package/@lynx-js/lynx-ui).

To see the components in action, grab [Lynx Explorer](/next/guide/start/quick-start.md#prepare-lynx-explorer), scan the QR codes in the [component demos](/next/ui/components/button.md), and see them running right away. Or bring it into your own Lynx app and try it in a real product flow.

We want lynx-ui to grow from the way real apps are built. If it feels great, gets in your way, or leaves something missing, let us know in the [lynx-family/lynx-ui repository](https://github.com/lynx-family/lynx-ui). Help shape what comes next.
