rea
Reverse engineer anything with agents, from app behavior down to native binaries.
- 474k
- TypeScript
- MIT
- 3 h ago
SeatLayer SDK for React Native and Expo: seat map and seat picker for iOS and Android ticketing apps, with live availability, seat holds, best available and 3D seat views.
Repo seatlayer/seatlayer-react-native, read from GitHub 9 h ago. seatlayer has not joined Take My Repo.
seatlayer/seatlayer-react-native is a public repo on GitHub by seatlayer. SeatLayer SDK for React Native and Expo: seat map and seat picker for iOS and Android ticketing apps, with live availability, seat holds, best available and 3D seat views. It declares the MIT license on GitHub. It is written mainly in TypeScript, has 1 stars and last changed on 2026-11-18. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
The official SeatLayer React Native seat map SDK adds an interactive seating chart and seat picker to React Native and Expo ticketing apps on iOS and Android. It combines live availability, best-available selection, temporary holds and typed TypeScript APIs with React Native buyer controls around the SeatLayer map, the same map buyers see on the web; your trusted server completes booking. SeatLayer is seating chart and reserved-seat ticketing software built for venues up to stadium scale.

Walk through the picker screen by screen: what the buyer sees from the venue overview to the checkout handoff, and which parts a host can turn off, restyle, or replace.
SeatLayer is reserved-seat ticketing and seating software: organizers sell with hosted checkout, a box office, door check-in and season tickets, and platforms add the same seat maps, with 3D seat views, through the SeatLayer SDK and API. One chart drives the 2D map, the 3D venue and the view from each seat (3D for venues up to 60,000 seats; the 2D map benchmarked at 200,000 seats).
Website · For developers · Season tickets · Pricing · Live demo
Season tickets are in the web and server SDKs today, not in this SDK.
@seatlayer/react-native on npm · SeatLayer SDK and API overviewHow it works: the buyer picks and holds seats in your app with your public key. Your server then reads the hold, takes the payment through your own provider, and books the seats with your secret key.
More from SeatLayer: SeatLayer iOS seat map SDK · SeatLayer Android seat map SDK · SeatLayer Flutter seat map SDK · SeatLayer AI Toolkit
Latest release: see the version on npm. Pin the version you tested, and test your event, checkout hand-off and target devices before release.
npm install @seatlayer/react-native
npx expo install react-native-webview
npm install @seatlayer/react-native react-native-webview
npx pod-install
React Native autolinks react-native-webview on Android and iOS. The package
ships no custom native module of its own, so there is nothing else to link.
Peer requirements are react >= 18.2.0, react-native >= 0.72.0, and
react-native-webview >= 13.0.0. TypeScript declarations are published with the
package (dist/index.d.ts for ESM and dist/index.d.cts for CommonJS), so no
@types/* package is needed.
Use SeatLayerPicker for the complete native buyer flow. Give it a definite
height or a full-screen parent, and keep the configuration object stable so
React rerenders do not reload the chart.
import React, { useMemo } from 'react';
import { SeatLayerPicker } from '@seatlayer/react-native';
export function TicketPicker({
event,
startCheckout,
}: {
readonly event: string;
readonly startCheckout: (holdId: string) => Promise<void>;
}) {
const configuration = useMemo(
() => ({
event,
publicKey: 'pk_test_your_key',
currency: 'USD',
maxSelection: 8,
}),
[event],
);
return (
<SeatLayerPicker
configuration={configuration}
themeMode="auto"
onCheckout={(handoff) => startCheckout(handoff.holdId)}
/>
);
}
onCheckout receives the typed hold handoff. Send it only to your trusted
backend for payment and idempotent booking.
Give the map a definite height or a full-screen parent. Keep the configuration object stable so React rerenders do not reload the chart.
import React, { useEffect, useMemo } from 'react';
import { View } from 'react-native';
import {
SeatLayerError,
SeatLayerView,
useSeatLayerController,
} from '@seatlayer/react-native';
export function SeatMapScreen({ event }: { readonly event: string }) {
const controller = useSeatLayerController();
const configuration = useMemo(
() => ({
event,
publicKey: 'pk_test_your_key',
currency: 'USD',
maxSelection: 8,
}),
[event],
);
useEffect(
() =>
controller.on('selectionChanged', (seats) => {
console.log('Selected seats', seats);
}),
[controller],
);
return (
<View style={{ flex: 1 }}>
<SeatLayerView
style={{ flex: 1 }}
controller={controller}
configuration={configuration}
onReady={(info) => {
console.log(
`SeatLayer ready: protocol=${info.protocolRevision} mode=${info.mode}`,
);
}}
onLoadError={(error) => {
console.error(error.code, error.message);
}}
/>
</View>
);
}
Drive checkout-related actions through the controller:
try {
const hold = await controller.bestAvailable(4);
if (hold) {
// Send only the hold id to your trusted backend.
await beginCheckoutOnServer(hold.holdId);
}
} catch (error) {
if (error instanceof SeatLayerError) {
showInventoryMessage(error.code, error.message);
}
}
For private channel inventory, mint short-lived buyer sessions on your backend
for the exact allowed origin https://cdn.seatlayer.io:
const configuration = useMemo(
() => ({
event,
buyerAccessTokenProvider: (context) =>
buyerBackend.mintSeatLayerAccess(context.reason),
}),
[event],
);
The native picker uses one immutable latest snapshot as its seam. Choose the integration level that matches the amount of application UI you want to own; all three paths keep the same typed checkout handoff and capability-gated actions.
SeatLayerPicker fills its bounded parent with the adaptive SeatLayer venue
map and native picker chrome.
import { SeatLayerPicker } from '@seatlayer/react-native';
<SeatLayerPicker
configuration={configuration}
themeMode="auto"
onCheckout={continueWithHandoff}
/>
Use SeatLayerPickerModal for a controlled dialog or full-screen presentation.
It uses the same scope, snapshot, and back ladder as the in-page picker.
import { SeatLayerPickerModal } from '@seatlayer/react-native';
<SeatLayerPickerModal
visible={isPickerOpen}
configuration={configuration}
onCheckout={continueWithHandoff}
onRequestClose={() => setPickerOpen(false)}
barrierDismissible
/>
Use typed options, theme roles, string overrides, visual style slots, and complete-part builders to change native chrome without changing picker state or actions.
<SeatLayerPicker
configuration={configuration}
themeMode="dark"
options={{
layout: 'adaptive',
chrome: { priceLegend: false },
haptics: true,
languages: ['en-GB', 'fr-FR'],
pricing: {
formatter: (amount, currency) =>
new Intl.NumberFormat('fr-FR', {
style: 'currency',
currency,
}).format(amount),
},
}}
locale="fr-FR"
strings={{ holdAndCheckout: 'Continue' }}
styles={{
headerContainer: { backgroundColor: '#172033' },
continueButton: { backgroundColor: '#5B4B8A' },
}}
builders={{ header: ({ defaultChild }) => defaultChild }}
onCheckout={continueWithHandoff}
/>
The customization layers have distinct ownership:
options controls session behaviour and which ready-made parts are visible.
options.max3DSeats: 3D opens for venues up to 60,000 seats; on a touch screen the default is 30,000 unless you set this option.themeMode and themeOptions map app colours, typography, radii, logos, and
map colours into one resolved theme.locale selects generated native wording; strings overrides any individual
label or plural formatter. options.languages supplies the runtime language
choices.styles provides 62 typed, aesthetic-only slots. Colour, type, borders,
radii, shadows, and opacity may change; SDK-owned placement, safe areas,
viewport insets, and 44-point minimum targets remain intact.builders replaces any of 25 complete parts (28 builder keys, three of them
alternative names) and receives the live scope plus defaultChild. Use a
builder when structure or placement must change.An app that wants the picker set in its own typeface passes
themeOptions.theme.fontFamily and loads the face itself (with expo-font,
react-native.config.js asset linking, or whatever the app already uses), and
every line the picker draws then takes that family. Without it the picker draws
the platform's own face, which is the right default: React Native has no
inherited text style, so a picker that guessed at the surrounding typography
would be guessing. Pass the family name the platform registers the face under,
and load every weight the app expects to see; a weight that is not loaded is
resolved to the nearest one that is.
Behaviour options worth knowing:
eventName names the event in the header before the runtime reports one, so
the title does not swap a second after the picker opens. It is never sent to
the runtime; the runtime's own name wins the moment it arrives.showBookedOverlay (default true) draws the picker's own "You're all set"
screen when the handed-off hold settles to booked. A host with its own
confirmation screen sets it false and listens to onBooked instead, so the
buyer is told once.showHoldPill (default true) draws the header's hold countdown for as long
as a live hold exists, whoever owns it. A host drawing its own clock sets it
false. It composes with chrome.holdPill: the pill appears only where both
are on.chrome.showDockBar shows the section dock bar. It is off by default on every
width; set it to true to show it. The older chrome.dock name still works,
and showDockBar wins when both are set.Callbacks are optional observations, never a place the SDK waits:
onReady · onChartLoad · onSelectionChanged · onSelectionValidityChanged ·
onHoldChanged · onHoldExpired · onBooked · onAccessExpired ·
onAccessUnavailable · onSelectedObjectUnavailable · onClosed · onError ·
onThemeResolved · onSectionFocused · onSeatSelected · onSeatRemoved ·
onSeatViewOpened · onSeatConfidence · onContinue
onBooked fires once, when the handed-off hold settles to booked, never on the
handoff itself, because a buyer on the way to pay has not paid.
onSeatConfidence is called when the buyer taps the seat-detail chip on the 3D
card. Leave it out and that detail shows as plain text.
options.pricing.formatter formats every native amount: confirmation, ticket
rows, GA/table tiers, peek, expanded cart, and best-available entry pricing.
It changes presentation only. Runtime selection, hold totals, and the trusted
server checkout remain authoritative; the SDK never recalculates inventory
prices from display text.
SeatLayerPickerScope owns one command controller and one latest immutable
snapshot. The standalone parts below read the same scoped theme, capabilities,
presentation state, and actions.
import { View } from 'react-native';
import {
SeatLayerCartSheet,
SeatLayerDockBar,
SeatLayerFloorStrip,
SeatLayerMapControls,
SeatLayerPickerAccessibilityFilters,
SeatLayerPickerChart,
SeatLayerPickerHeader,
SeatLayerPickerHoldCountdown,
SeatLayerPickerScope,
SeatLayerPickerViewModeControl,
SeatLayerPriceLegend,
} from '@seatlayer/react-native';
<SeatLayerPickerScope configuration={configuration} themeMode="auto">
<SeatLayerPickerHeader />
<SeatLayerPickerHoldCountdown />
<SeatLayerPriceLegend />
<SeatLayerFloorStrip />
<View style={{ flex: 1, position: 'relative' }}>
<SeatLayerPickerChart style={{ flex: 1 }} />
<SeatLayerPickerViewModeControl />
<SeatLayerMapControls
includeViewModeControl={false}
showAccessibilityControl={false}
/>
<SeatLayerPickerAccessibilityFilters />
</View>
<SeatLayerDockBar />
<SeatLayerCartSheet
expanded={isCartExpanded}
onExpandedChanged={setCartExpanded}
onCheckout={continueWithHandoff}
/>
</SeatLayerPickerScope>
Call useSeatLayerPicker() inside the scope when your own component needs the
latest snapshot, resolved theme, capability availability, presentation state,
or scoped actions.
The same scope also supports standalone confirmation and seat-view actions,
best seats, section navigation, floor selection, GA/table prompts, dense cart
lists, hold-lapse recovery, loading/error/empty states, attribution, venue 3D,
and panorama chrome. Custom ticket trays can reuse the exported
resolveSeatLayerTicketLines helper instead of reimplementing the ticket-line
rules: it turns cart items into lines with their section, row, seat, category,
price and quantity.
SeatLayerPickerController carries the picker's own commands alongside the
venue-map ones. Reach it as controller from useSeatLayerPicker() inside a
SeatLayerPickerScope. The chrome-facing members:
| Member | What it does |
|---|---|
setSelectionFocus(seatId | null) |
Names the seat a host-drawn card is asking about, so the runtime paints it as the candidate. null clears the paint. |
setBlockedRegions(regions | null) |
Reports where native chrome lies over the map, in the map's own pixels, so the runtime swallows a touch that starts inside one. |
frameSeat(seatId, options) |
Pans (never zooms) so a seat rests in the band the reported insets leave clear. Answers dy: 0 for a seat already in place, an unknown seat, insets that leave no band, or a stale gesture count. |
focusAccessibilityFilter() |
Flies to the matches of the filter already on, leaving the filter alone. |
focusNextAccessibleSection(types?) |
Steps to the next section holding a free matching space, in chart order, wrapping. null (nothing matches) is an answer; undefined means the runtime does not offer the tour. |
subscribeSeatRetap(listener) |
A seat already in the selection tapped again. Subscribing never replays an earlier event. |
subscribeBooked(listener) |
Fires once per sale, with the handoff that became it. |
getCheckoutHandoff() / getBookedHandoff() |
The handoff this picker made, and the one whose hold settled to booked. |
releaseHandoffAndChangeSeats() |
Gives a handed-off hold back so the seats go on sale again and the buyer picks afresh. Answers false where there is no handoff or the runtime does not offer the reject. |
releasePickerOwnedHold() |
Releases a picker-owned hold after earlier queued mutations have settled. |
refreshAvailability() / holdSelection({ ttlMs }) |
Re-reads live availability; holds the current selection. |
Each command is gated on what the loaded runtime advertises, and the matching
getter says so before you call: supportsSelectionFocus,
supportsBlockedRegions, supportsFrameSeat, supportsAccessibilityFocus,
supportsAccessibleSectionTour, supportsHandoffReject,
supportsAvailabilityRefresh, supportsHoldSelection. A command the runtime
does not offer resolves with nothing rather than rejecting: a capability the
runtime does not advertise is a feature this host does not offer, never a
failure.
SeatLayerPickerBlockedRegionSurface, SeatLayerPickerBlockedRegion and
useSeatLayerPickerBlockedRegionCover measure and report those rectangles for
you when you compose your own chrome, including the 600 ms a rectangle keeps
guarding after its control has gone.
While the seat card is up, the map goes behind a veil with a feathered hole
around the tapped seat, so the buyer can still see the seat they are being
asked about. React Native has no blur of its own, and a native blur module
cannot be a hard dependency: a bundler resolves require statically, so an
app without the module could not build.
An app that already has one installs it once, at start-up:
import { BlurView } from '@react-native-community/blur';
import { setSeatLayerPickerSpotlightBlur } from '@seatlayer/react-native';
setSeatLayerPickerSpotlightBlur(BlurView);
Without it the glass is the plain veil, which is a correct state and not a
degraded one. Pass undefined to remove it again. The picker drops the blur
and deepens the veil by itself when the buyer has asked for reduced
transparency.
A seat can say what it is (an accessible physical seat, an empty wheelchair
space, a restricted view, a premium seat), and each of those wears a drawing
shared with every other SeatLayer SDK, so the same seat wears the same mark
everywhere. With no drawing dependency the picker hands each glyph to Image
as an SVG data URI.
On iOS that fallback draws nothing. Image decodes a data URI through the
platform's own image decoders, and none of them reads SVG, so the seat-note
bands on the seat card and the rows of the accessibility sheet keep their words
and lose the mark beside them. Nothing else changes (no gap, no broken box,
no error), but if you want the marks on iOS, install the renderer below.
react-native-svg is an optional peer. An app that already has it installs
the built-in vector renderer once, at start-up, and every glyph is drawn
natively instead, scaling without resampling and taking each row's ink
directly:
import Svg, { Circle, Path } from 'react-native-svg';
import { installSeatLayerPickerSvgIcons } from '@seatlayer/react-native';
installSeatLayerPickerSvgIcons({ Svg, Path, Circle });
You pass your own imports rather than the SDK requiring the module, for the
same reason as the blur above: a bundler resolves require statically, so a
guarded import here would put react-native-svg in every consumer's build
graph whether they wanted it or not. Circle is optional; without it the
circles in a glyph are drawn as paths. Pass undefined to go back to the data
URI, and setSeatLayerPickerSeatIconRenderer to draw them some other way
entirely.
pnpm install
cd example && pnpm install && pnpm start
example/App.tsx is a minimal Expo app using the production ready-made picker
and secure checkout handoff. Set
EXPO_PUBLIC_SEATLAYER_EVENT and, for public startup,
EXPO_PUBLIC_SEATLAYER_PUBLIC_KEY before starting it; when the event is absent,
the example shows setup guidance and does not mount a picker. The browser-based
buyer seat-map demo is a preview of the
wider SeatLayer buyer experience, not a React Native app.
To build and test the package itself, see CONTRIBUTING.md.
The React Native app selects and holds inventory. Your trusted backend inspects and books the hold after payment or order validation.
holdId and your normal checkout context to your backend.Continue with seat holds and secure server-side checkout before connecting payment and booking.
SeatLayerView shows the SeatLayer venue map, the same map as on the web,
inside your app. Each SDK release uses one matching map version, exported as
seatLayerHostedWebVersion. Register https://cdn.seatlayer.io on the
publishable key used for public startup. For private inventory, omit publicKey
and use buyerAccessTokenProvider; buyer access tokens stay in memory and are
never placed in a page URL, a React key or an event payload.
Your code never touches the map directly. It works through a typed TypeScript controller whose contract matches the Web, iOS and Flutter SDKs: every command gets one answer, or a timeout error after 15 seconds.
Prepare the picker in advance (optional). SeatLayerRuntimePrewarm fetches
the venue map files before the picker opens. The result expires after a short
time and is dropped under memory pressure.
hold · resumeHold · extendHold · release · releaseLabels ·
bestAvailable · holdGA · setSeatTier · getSelection ·
selectObjects · deselectObjects · clearSelection · selectCategories ·
deselectCategories · setSelectableObjects · setMaxSelection ·
getSelectionValidity · refreshAccess · getCurrentHold · getGAAreas ·
getFloors · setFloor · setColorblindSafe · setViewMode ·
getViewMode · zoomIn · zoomOut · zoomToFit · destroy
Every command returns a promise. Failures reject with SeatLayerError.
Inventory outcomes such as sold_out, not_enough_together, expired holds, and
hold conflicts remain distinct codes suitable for buyer-facing recovery.
Subscribe with controller.on(name, listener). The returned function removes
the listener.
useEffect(() => {
const offHold = controller.on('holdChanged', persistOpenHold);
const offExpired = controller.on('holdExpired', returnBuyerToSelection);
const offError = controller.on('error', reportSeatLayerError);
return () => {
offHold();
offExpired();
offError();
};
}, [controller]);
Events: ready · selectionChanged · holdChanged · holdRestored ·
holdExpired · selectionValidityChanged · selectionValid ·
selectionInvalid · selectionLimit · accessExpired · accessUnavailable ·
selectedObjectsUnavailable · error · hint · gaClick · seatHover ·
deckTap · checkout · unknownEvent
Unknown future events remain observable through unknownEvent, so a new map
event never crashes an older app.
ScrollView. The canvas owns pan and pinch for map navigation.configuration stable with useMemo.reloadKey to reload the map on purpose.useSeatLayerController disposes the controller automatically on unmount.holdId and call resumeHold after app restoration.The ready-made picker declares its own reading order, type-size ceilings, live regions and focus handling. Two of those need something from the host app.
The picker walks a screen reader through the seat map in buyer order (event,
prices, map, then the tray) rather than in the order the views happen to be
painted. It declares that with React Native's own
experimental_accessibilityOrder, naming the nativeID of each surface at the
composition root.
On iOS that prop is only honoured when the app turns the native feature flag on. Without it, nothing breaks and nothing is announced twice: VoiceOver simply falls back to the paint order, in which the cart tray is reached before the map. On Android the order is honoured without a flag.
Turn it on once, early in the app's native start-up, before the first React
Native view is created, in AppDelegate:
// AppDelegate.mm, above [super application:didFinishLaunchingWithOptions:]
#import <React/RCTConstants.h>
RCTSetAccessibilityElementOrderEnabled(YES);
or, in a Swift AppDelegate:
RCTSetAccessibilityElementOrderEnabled(true)
Expo apps reach the same file through a config plugin or a prebuild; a managed project that cannot run native code does not get the declared order, and the picker stays usable on the fallback.
Check your React Native version's release notes for the flag's exact name: it has been an experimental API, and the SDK deliberately spreads the prop rather than typing it, so a runtime that does not know it simply ignores it.
Bold Text and the platform's text-size setting are answered by the picker
itself, with no host wiring: every weight the picker states moves up one step
(200, clamped at 900) while Bold Text is on, and each surface caps how far
its type may grow so a sheet cannot push its own buttons off screen. The
card's answer scales down before it truncates, and the boxes grow with the
type they hold.
No host code is needed for the rest, and all of it follows the platform's own settings:
options.haptics, and a platform that
refuses one is not an error the buyer sees;accessibility-focus-v1, a provision's free count is a button that turns it
on, applies the filter and frames the first section holding a matching space,
and a stepper beside the accessibility control walks the rest.Yes. @seatlayer/react-native gives React Native and Expo apps on iOS and
Android a ready-made seat picker: live availability, seat selection, best
available, holds, a cart, 3D and the view from a seat for venues up to 60,000
seats, and a checkout hand-off to your backend. The controls are React Native
components with typed TypeScript APIs, and the seat map itself is the SeatLayer
map from the web, shown inside your app. You pay only for sold seats, with 100
free every month, and the same charts run on the web, iOS, Android and Flutter.
Install @seatlayer/react-native with react-native-webview, then render
SeatLayerPicker with your event key and publishable key in a full-screen or
fixed-height parent. That one component is the whole buyer flow: the live seat
map, filters, seat confirmation, cart, holds, best available, 3D for venues up
to 60,000 seats, and the checkout hand-off. Use SeatLayerView with
useSeatLayerController() only when your app draws every control itself.
The picker controls around the seat map are React Native components, and your code works through typed TypeScript commands, payloads, errors and events. The seat map itself is the SeatLayer map from the web, shown inside your app; the package adds no custom native module (no podspec and no Swift, Kotlin, Java or Objective-C source).
Building and testing is free: test mode has no time limit, needs no card and uses no credits. Live, you pay per sold seat: the first 100 sold seats each month are free, then 10 cents down to 5 cents a seat, with no subscription, and credits you buy never expire.
Yes. The only required native dependency is react-native-webview, which Expo
Go already includes, so npx expo install react-native-webview is enough on a
supported Expo SDK. Development builds and bare React Native projects work the
same way, and the repository's example/ app is an Expo app.
When a buyer goes to checkout, the SeatLayer picker holds the seats they picked
for that buyer for a set time, which you can change per event, so no other buyer
can take them. A hold that is never booked expires on its own: onHoldExpired
tells your app, or the holdExpired event with SeatLayerView, where your code
calls hold() itself. extendHold and resumeHold cover longer checkouts and
app restarts.
The package needs react >= 18.2.0, react-native >= 0.72.0 and
react-native-webview >= 13.0.0, and it is developed and tested against React
Native 0.86 and React 19. react-native-svg >= 13.0.0 is an optional peer: pass
it to installSeatLayerPickerSvgIcons to draw the seat-note marks on iOS. iOS
and Android are both supported, and the package ships ESM, CommonJS and
TypeScript declarations.
llms.txt) for an agent-readable map of the documentation.| Surface | Package or source |
|---|---|
| React Native | @seatlayer/react-native (this package) |
| JavaScript | @seatlayer/js |
| React | @seatlayer/react |
| Vue | @seatlayer/vue |
| Angular | @seatlayer/angular |
| iOS | seatlayer-ios |
| Flutter | seatlayer |
| Android | seatlayer-android |
| Server SDKs | Node.js, Python, PHP, Ruby, .NET, Java, and Go |
Benchmarked on public 100,000-, 150,000- and 200,000-seat venue fixtures on 15 September 2026: 200,000 seats chart-ready in 1.95 s, desktop, local production build. Tested at 10,000 simulated concurrent buyers on one 12,000-seat event (18 September 2026): engine-side hold latency p99 9 ms, zero server errors. Method, fixtures and run files: https://github.com/seatlayer/seatlayer-performance. Live 200,000-seat stadium demo: https://app.seatlayer.io/demo/play/century-stadium-200k.
MIT © SeatLayer
seatlayer/seatlayer-react-native is a public repo on GitHub by seatlayer. SeatLayer SDK for React Native and Expo: seat map and seat picker for iOS and Android ticketing apps, with live availability, seat holds, best available and 3D seat views.
It declares the MIT license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-18. GitHub counts 0 open issues and pull requests. Take My Repo does not judge from that whether it is maintained.
Reverse engineer anything with agents, from app behavior down to native binaries.

Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
An open-source framework for making universal native apps with React. Expo runs on Android, iOS, and the web.
Flutter makes it easy and fast to build beautiful apps for mobile and beyond
A framework for building native applications using React
f.k.a. Awesome ChatGPT Prompts. Share, discover, and collect prompts from the community. Free and open source — self-host for your organization with complete privacy.
Infinite Red's battle-tested React Native project boilerplate, along with a CLI, component/model generators, and more! 9 years of continuous development and counting.
SeatLayer SDK for React, Vue and Angular: interactive seat map, seating chart and seat picker with live availability, seat holds, best available, 3D seat views and season tickets for web ticketing apps.
SeatLayer SDK for Flutter: seat map and seat picker for iOS and Android ticketing apps, with Flutter widgets for the buyer flow, live availability, seat selection, holds and 3D seat views.
Measured, reproducible performance evidence for SeatLayer: 200,000-seat stadium chart benchmarks and a 10,000-buyer single-event concurrency test, with fixtures, methods, run files and SHA-256 manifests.
SeatLayer SDK for Android: interactive seat map and native seat picker for Kotlin and Jetpack Compose ticketing apps, with live availability, seat holds, best available and 3D seat views.
SeatLayer SDK for iOS: interactive seat map and native seat picker for Swift and SwiftUI ticketing apps, with live availability, seat holds, best available and 3D seat views.
SeatLayer Node.js SDK for reserved seating: seat booking, holds, events, season tickets and webhook verification from your Node.js backend, with retries and idempotency built in.
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/seatlayer/seatlayer-react-nativeTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.