# Software Mansion > Core React Native Contributors | RTC & Video Streaming Experts | Trusted by Huawei, Expo, Shopify, Starkware & more | Ready to help with your project Software consultancy. React Native core contributors, multimedia and real-time communication, Elixir, and AI. Full page contents are available at https://swmansion.com/llms-full.txt, and any page returns markdown when requested with `Accept: text/markdown`. ## Services - [React Native New Architecture Migration](https://swmansion.com/services/react-native-new-architecture/): Migrate your React Native app to the New Architecture with engineers who work on React Native, Expo, and the libraries your app depends on. - [React Native Performance Optimization](https://swmansion.com/services/react-native-performance-optimization/): We diagnose and fix the React Native bottlenecks behind slow screens, battery drain, crashes, and poor app responsiveness. - [React Native Brownfield Integration](https://swmansion.com/services/react-native-brownfield-integration/): Add React Native to your existing native app with the engineers who built expo-brownfield. - [React Native Animations & Interactions](https://swmansion.com/services/react-native-animations-interactions/): Build smooth React Native animations, gestures, GPU effects, and interaction-heavy experiences with the team behind Reanimated and Gesture Handler. - [On-Device AI & Local AI Development](https://swmansion.com/services/on-device-ai-and-local-ai-development/): Build private, offline AI features for mobile apps with the team behind React Native ExecuTorch. - [React Native Upgrades, Migrations & Modernization](https://swmansion.com/services/react-native-upgrades/): Upgrade and modernize your React Native app without disrupting your development workflow. - [Consulting & Advisory](https://swmansion.com/services/consulting-and-advisory/): Architecture reviews, migration planning, performance work, and production debugging – senior engineers who help you decide what to build and fix what is already broken. - [Real-Time Video & Motion](https://swmansion.com/services/real-time-video-and-motion/): Low-latency real-time video, live streaming, and smooth animations – built by the team behind Reanimated, Gesture Handler, and Fishjam. - [Team Augmentation](https://swmansion.com/services/team-augmentation/): Extend your engineering team with senior product engineers who contribute from day one – embedded, as a senior extension, or as consultants. - [Software Development](https://swmansion.com/services/build-a-new-product/): Product design, mobile, web, backend, and QA under one roof – we help founders and Fortune 500 teams get from idea to launch with fewer wrong turns. - [Mobile App Modernization](https://swmansion.com/services/mobile-app-modernization/): We modernize React Native apps – audits, tech debt reduction, migrations, and major upgrades – without disrupting your release cycle. - [Software Development for AI](https://swmansion.com/services/ai-development/): Production-ready AI features, on-device inference, and agentic engineering workflows from a team that was building AI-powered products long before the hype. ## Products - **React Native**: We are the creators of core React Native libraries used by developers around the world. We had taken part in building the framework even before it became open source, shaping the ecosystem from the start. - **React Native Reanimated**: The go-to library for building animations in React Native. Reanimated powers most React Native apps out there. - **React Native Gesture Handler**: It brings the native platform’s touch and gesture system to React Native through a simple, declarative API. - **Expo**: A full-stack React Native framework with cloud services that speed up every stage of app development. We are behind major parts of Expo SDK. We build Expo libraries for brownfield integration, live activities, Meta Quest, and more. - **Detour**: A developer-first library for deferred deep links that resolves context across installs, preserves parameters, and gets users to the right screen without extra setup. - **React Native Audio API**: The library lets you build powerful in-app audio features like real-time visualization, multi-track playback, and more. - **React Native Screens**: It provides native navigation primitives for React Native apps. Our library powers React Navigation and Expo Router. - **React Native SVG** - **React Native Wallet**: The library simplifies adding payment cards to Google and Apple Wallet with a ready-to-use component. - **React Navigation** - **Pulsar**: Ready-to-use haptic presets, a pattern composer for custom haptic sequences, and a real-time composer for gesture-driven feedback. - **React Native Shine**: A fast and efficient way to add interactive GPU-based shader effects to your React Native apps using TypeGPU and WebGPU. - **React Native Enriched**: React Native Enriched is a family of HTML, markdown, and text streaming packages that let you enrich your app with truly native React Native components for rich text rendering and editing. - **Simcam**: The Mac app that lets you stream your camera into the iOS Simulator to test scanning, image recognition, and capture features without a physical device. - **React Native Bottom Sheet**: It provides native bottom sheet components for React Native, letting you build inline and modal sheets with fully custom content, dynamic sizing, smooth native gestures, and more. - **Radon**: The VSCode and Cursor extension that turns your editor into a complete IDE for React Native and Expo development. - **React Native Worklets**: The library makes it possible to run JavaScript code in parallel across multiple threads and runtimes, boosting app performance. - **Smelter**: Our tool for low-latency live video mixing. It is perfect for streaming, broadcasting, and video conferencing. - **Multimedia & RTC**: We have become experts in developing multimedia and WebRTC tools and frameworks. We have created advanced streaming platforms, multimedia frameworks, and video mixers. - **TypeGPU**: The library that enhances the WebGPU API, enabling type-safe, declarative resource management. - **Fishjam**: Real-time media platform powering video conferencing, interactive streaming, AI voice agents, and video compositing. - **gpu-video**: Our open-source rust library for intuitive and painless cross-platform hardware video decoding and encoding - **Membrane**: The versatile multimedia streaming and processing framework that lets you build media servers tailored to your needs. - **Elixir Libraries**: We started working with the Elixir language when building the Membrane framework. Since then, we have been active in the community, working on debugging tools, browser integration solutions, and WebRTC implementations. - **Live Debugger**: Our browser-based tool for debugging LiveView apps, built to improve the Elixir developer experience. - **Popcorn**: The library that brings Elixir to the browser. It lets you call functions, spawn processes, and compile code on the client side. - **Elixir WebRTC**: The WebRTC implementation for the Elixir ecosystem. It is easy to use with Phoenix, Membrane, or Elixir Nx. - **Argent**: An agentic toolkit to control, debug, and profile iOS and Android applications. Your agent can navigate your app, explore the component tree, inspect network requests, and trace performance problems in your mobile apps. - **AI**: We first used AI to develop software for removing objects from live video feeds. That’s how we began working on low-latency video AI. Now, we build tools that run LLMs locally, keeping data secure and private. - **React Native Executorch**: The library that lets you run LLMs and AI models fully on-device, with a declarative API powered by ExecuTorch. - **Private Mind**: The fully offline AI chat app that showcases what is possible with React Native RAG and React Native ExecuTorch. - **React Native RAG**: Our on-device RAG library that offers full privacy and offline capability. You can use it to supercharge LLMs with your local knowledge base. - **Blockchain**: We build developer tools for blockchain ecosystems. Our projects provide infrastructure for smart contract development and package management, supporting developers who work on decentralized networks. - **Scarb**: The build toolchain and package manager for Cairo and Starknet ecosystems. - **Starknet Foundry**: The toolchain for creating, testing, and deploying smart contracts on the Starknet network. ## Case studies - [300% More Active Users of a Camping App Developed with React Native](https://swmansion.com/case-studies/campy/): Learn how we built the React Native app for nomads, motorhome enthusiasts, and campervan travelers – helping Campy triple its active user base. - [Boosting Stability and Reducing Technical Debt for a User Research Platform](https://swmansion.com/case-studies/dscout/): We teamed up with Dscout to improve its video research tool and refresh the platform by moving the admin panel to Elixir, making it more scalable, faster, and easier to maintain. - [Bringing Real-Time Audio to a Public Benefit Corporation Messaging Platform with Elixir WebRTC](https://swmansion.com/case-studies/turnio/): Turn.io helps organizations and governments connect underserved communities with health workers, NGOs, and ministries. Read how we added real-time voice calls, live transcriptions, and an AI assistant to their platform. - [Delivering Precise Playback & Cutting Audio Preloading by 85% in a Content Aggregator App](https://swmansion.com/case-studies/perch/): We introduced advanced text-to-speech features to the Perch content aggregator app, reducing audio preload time from 10s to 1.5s and significantly improving playback experience. - [Modernizing Photobucket's React Native App – and the Team Behind It](https://swmansion.com/case-studies/photobucket/): We helped Photobucket modernize their React Native app, improve developer experience, and build a stronger foundation for future growth. - [Developing a Medspa Platform That Contributed to 10x Client Growth](https://swmansion.com/case-studies/moxie/): We partnered with Moxie to build all-in-one software for medspa management, streamlining their operations. Our collaboration continues – we add new features and maintain platform stability at 99.85%. - [From Zero to 300K Users in One Year: How We Built an App That Builds Apps](https://swmansion.com/case-studies/vibecode/): We helped Vibecode build a platform that lets anyone develop fully functional mobile & web apps directly from their phone or web. - [Optimizing Battery Usage & Improving Crash-Free Rate for the Boating Community](https://swmansion.com/case-studies/seapeople/): Read how we helped SeaPeople refine its boating app by improving Android performance and adding new social features. - [Cutting Live Broadcast Latency From 7 to 2 Seconds for a Group Chat App](https://swmansion.com/case-studies/chatbcc/): We built ChatBCC's Live Spaces using Fishjam, our multimedia hub solution, reducing broadcast latency from 7 to around 2 seconds. - [Optimizing Performance and Building a Rich Text Editor for a Chat Platform](https://swmansion.com/case-studies/filament/): We improved an invite-only networking app and built an open-source rich text editor for React Native. As part of this collaboration, we also boosted Filament's Android performance, cutting app launch time from 6–10 s to under 1 second. - [Refining an Event Planning App That Won Google Play’s Best App Award](https://swmansion.com/case-studies/partiful/): Read how we partnered with Partiful to upgrade its Android app, improve usability and stability to boost engagement, retention, and user satisfaction. - [Modernizing Real-Time Infrastructure and Improving Observability for Supabase](https://swmansion.com/case-studies/supabase/): Learn how we collaborated with Supabase to modernize their Realtime.js SDK and improve the Logflare observability tool. ## Blog (190 articles) - [The Memory Hermes Can't See: Stale Shadow Nodes in React Native](https://swmansion.com/blog/the-memory-hermes-cant-see-stale-shadow-nodes-in-react-native/) - [Demuxed vs RTC.ON: Which Video Engineering Conference Should You Attend in 2026?](https://swmansion.com/blog/demuxed-vs-rtcon-2026/) - [How Worklets Bundle Mode accidentally fixed Hermes V1 memory regression](https://swmansion.com/blog/how-worklets-bundle-mode-accidentally-fixed-Hermes-v1-memory-regression/) - [Edge AI in Production: What Apple, Meta, and Google Already Ship On-Device](https://swmansion.com/blog/edge-ai-in-production-what-apple-meta-and-google-already-ship-on-device/) - [Closing the Agent Loop: Autonomous React Native Bug Reproduction with Argent](https://swmansion.com/blog/closing-the-agent-loop-autonomous-react-native-bug-reproduction-with-argent/) - [We Built the Same App in KMP and React Native – Here's What We Found](https://swmansion.com/blog/we-built-the-same-app-in-kmp-and-react-native-here-s-what-we-found/) - [LiveStash Performance Tests](https://swmansion.com/blog/live-stash-performance-tests/) - [Control Your iOS Simulator with an AI Agent on a Local LLM](https://swmansion.com/blog/control-your-i-os-simulator-with-an-ai-agent-on-a-local-llm/) - [The missing layer in live video streaming APIs: programmable video composition](https://swmansion.com/blog/the-missing-layer-in-live-video-streaming-ap-is-programmable-video-composition/) - [MoQ Boy Escaped the Browser: Building a Native Mobile MoQ Client with moq-kit](https://swmansion.com/blog/moq-kit-native-mobile-moq-client/) - [What Is the Difference Between iOS and Android Haptics](https://swmansion.com/blog/what-is-the-difference-between-i-os-and-android-haptics/) - [MoQKit: A Native Mobile SDK for MoQ on iOS and Android](https://swmansion.com/blog/moqkit-native-mobile-sdk-moq-ios-android/) - [App.js Conf 2026 Recap: Gesture Handler 3.0, TypeGPU CLI, Screens 5.0, and More](https://swmansion.com/blog/app-js-conf-2026-recap-gesture-handler-3-0-type-gpu-cli-screens-5-0-and-more/) - [Livestreaming Trilemma: HLS, WEBRTC, MOQ](https://swmansion.com/blog/livestreaming-trilemma-hls-webrtc-moq/) - [Prompts Shouldn’t Be Tested by Eye. Here’s How to Measure Them Properly](https://swmansion.com/blog/prompts-shouldn-t-be-tested-by-eye-here-s-how-to-measure-them-properly/) - [Introducing Gesture Handler 3.0: Hook-Based API, Deeper Reanimated Integration & More](https://swmansion.com/blog/introducing-gesture-handler-3-0-hook-based-api-deeper-reanimated-integration-more-9185b0c8e305/) - [How AI Improves Backend Development Efficiency in 2026](https://swmansion.com/blog/how-ai-improves-backend-development-efficiency-in-2026/) - [Why Live Video Compositing Still Requires a DevOps Team (And How to Fix That)](https://swmansion.com/blog/live-video-compositing-devops/) - [Best Video Conferences in 2026: A Developer's Guide to Streaming, WebRTC, and MoQ Events](https://swmansion.com/blog/best-video-conferences-2026/) - [How Haptic Feedback Affects Sales, Trust, and Product Perception](https://swmansion.com/blog/how-haptic-feedback-affects-sales-trust-and-product-perception/) - [Meet Argent: Agentic Toolkit to Control, Debug and Profile iOS applications](https://swmansion.com/blog/argent-agentic-toolkit-to-control-debug-and-profile-ios-applications/) - [Expo to Meta Quest in Minutes: AI-Powered VR Development](https://swmansion.com/blog/expo-to-meta-quest-ai-powered-vr-development/) - [The Story of Building the SeaPeople App: “Strava for Boaters” [Software Mention podcast]](https://swmansion.com/blog/the-story-of-building-the-sea-people-app-strava-for-boaters-software-mention-podcast/) - [Integrating Deferred Deep Linking in React Native Apps ](https://swmansion.com/blog/integrating-deferred-deep-linking-in-react-native-apps-1/) - [Haptics Is Music: How to Design Haptic Patterns That Feel Right](https://swmansion.com/blog/haptics-is-music-how-to-design-haptic-patterns-that-feel-right/) - [How We Built Per-Section Applause with Claude Code (a.k.a. Medium Clone)](https://swmansion.com/blog/how-we-built-per-section-applause-with-claude-code-a-k-a-medium-clone/) - [AI Made 20 Years of Learning Obsolete in 2 Months – Simon Grimm x Tomek Zawadzki [Software Mention podcast] ](https://swmansion.com/blog/ai-made-20-years-of-learning-obsolete-in-2-months-simon-grimm-x-tomek-zawadzki-software-mention-podcast/) - [Deferred Deep Linking for Mobile Developers with Detour ](https://swmansion.com/blog/deferred-deep-linking-for-mobile-developers-with-detour/) - [5 Backend Development Best Practices in an AI Era](https://swmansion.com/blog/5-backend-development-best-practices-in-an-ai-era/) - [On-Device AI Beats Cloud for TTS – Here’s Why](https://swmansion.com/blog/on-device-ai-beats-cloud-for-tts-heres-why/) - [Live Video Broadcasting: From Scratch to Production With Membrane](https://swmansion.com/blog/live-video-broadcasting-from-scratch-to-production-with-membrane/) - [Haptic Feedback Explained: What It Is and What It Does for Your App (and Business)](https://swmansion.com/blog/haptic-feedback-explained-what-it-is-and-what-it-does-for-your-app-and-business/) - [What I Learned Running 3 Claude Agents in Parallel for a Week](https://swmansion.com/blog/what-i-learned-running-3-claude-agents-in-parallel-for-a-week/) - [React Native ExecuTorch v0.8.0 – A Library Milestone](https://swmansion.com/blog/react-native-executorch-v0.8.0-a-library-milestone/) - [The Problem of Reconnects in Phoenix LiveView](https://swmansion.com/blog/the-problem-of-reconnects-in-phoenix-live-view/) - [Worklets 0.8: The Shareable — Shared Memory’s Missing Piece](https://swmansion.com/blog/worklets-0-8-the-shareable-shared-memorys-missing-piece-d8880d4f2e7b/) - [The Three-Lang Problem: shipping Elixir runtime, JS, and WebAssembly as one npm package](https://swmansion.com/blog/the-three-lang-problem-shipping-elixir-runtime-js-and-webassembly-as-one-npm-package-5a7b76ad5b90/) - [Breaking Down the Jelly Slider](https://swmansion.com/blog/breaking-down-the-jelly-slider-9ab9239f6d80/) - [The Future of Video in React Native: Moving from expo-av to expo-video](https://swmansion.com/blog/the-future-of-video-in-react-native-moving-from-expo-av-to-expo-video-6f4f78e51196/) - [Behind the Scenes of React Native Multithreading: Vision Camera V5 x React Native Worklets](https://swmansion.com/blog/behind-the-scenes-of-react-native-multithreading-vision-camera-v5-x-react-native-worklets-a102c37b32ae/) - [Voice AI: How We Built a Multi-Speaker AI Agent using Gemini](https://swmansion.com/blog/voice-ai-how-we-built-a-multi-speaker-ai-agent-using-gemini-a59e08fb18aa/) - [Building Agents With LangGraph Part 4/4: How We Built Our Marketing Agent](https://swmansion.com/blog/building-agents-with-langgraph-part-4-4-how-we-built-our-marketing-agent-594a5a42de8b/) - [Huawei x Software Mansion: Bringing React Native Support to HarmonyOS NEXT](https://swmansion.com/blog/huawei-x-software-mansion-bringing-react-native-support-to-harmonyos-next-82e02bd75549/) - [Building Agents With LangGraph Part 3/4: RAG and Long-Term Memory](https://swmansion.com/blog/building-agents-with-langgraph-part-3-4-rag-and-long-term-memory-ed34d4d96972/) - [React Native in 2026: Trends & Our Predictions](https://swmansion.com/blog/react-native-in-2026-trends-our-predictions-463a837420c7/) - [On-Device Image Semantic Search: Recreating Apple & Google Photos in React Native — Part 4](https://swmansion.com/blog/on-device-image-semantic-search-recreating-apple-google-photos-in-react-native-part-4-1aeedc044289/) - [Building Agents With LangGraph Part 2/4: Adding Tools](https://swmansion.com/blog/building-agents-with-langgraph-part-2-4-adding-tools-a7955432c220/) - [React Native Debugging: New Performance Panel in React Native 0.83](https://swmansion.com/blog/react-native-debugging-new-performance-panel-in-react-native-0-83-21ca90871f6d/) - [Kotlin Multiplatform: Benefits, Limitations & Our Contributions](https://swmansion.com/blog/kotlin-multiplatform-benefits-limitations-our-contributions-560a148d28c9/) - [Building AI Agents With LangGraph Part 1/4: A Basic Chatbot](https://swmansion.com/blog/building-ai-agents-with-langgraph-part-1-4-a-basic-chatbot-ac4d2ad10bed/) - [Introducing Reanimated 4.2.0](https://swmansion.com/blog/introducing-reanimated-4-2-0-71eea21ca861/) - [Spec-tacular: How I Made Multimedia Technical Specifications Easier to Digest](https://swmansion.com/blog/spec-tacular-how-i-made-multimedia-technical-specifications-easier-to-digest-fb4d229e1b23/) - [RNRepo: Faster React Native Builds Through Prebuilt Artifacts](https://swmansion.com/blog/rnrepo-faster-react-native-builds-through-prebuilt-artifacts-004903b5e510/) - [Building Pufferfish: The Absurd Tech Demo That Turns Devs Into Fish](https://swmansion.com/blog/building-pufferfish-the-absurd-tech-demo-that-turns-devs-into-fish-c322120d2417/) - [Building an AI-Powered Note-Taking App in React Native — Part 4: Automatic Speech Recognition](https://swmansion.com/blog/building-an-ai-powered-note-taking-app-in-react-native-part-4-automatic-speech-recognition-a3b50e7d2245/) - [You May Not Need Reanimated Measure](https://swmansion.com/blog/you-may-not-need-reanimated-measure-5b9c11d27ba4/) - [Building an AI-Powered Note-Taking App in React Native — Part 3: Local RAG](https://swmansion.com/blog/building-an-ai-powered-note-taking-app-in-react-native-part-3-local-rag-868ba75f818b/) - [Building an Integrated React Native Brownfield App Using Expo: Step-by-Step Android Guide](https://swmansion.com/blog/building-an-integrated-react-native-brownfield-app-using-expo-step-by-step-android-guide-ee341c0fd982/) - [Building an AI-Powered Note-Taking App in React Native — Part 2: Image Semantic Search](https://swmansion.com/blog/building-an-ai-powered-note-taking-app-in-react-native-part-2-image-semantic-search-0456895cdf17/) - [Demuxed 2025 — Recap by Software Mansion](https://swmansion.com/blog/demuxed-2025-recap-by-software-mansion-0cfb07aaed15/) - [How to Add Vega OS Support to Your React Native App](https://swmansion.com/blog/how-to-add-vega-os-support-to-your-react-native-app-2b689d939492/) - [React Native’s New Architecture: The Tricky Parts (3/4)](https://swmansion.com/blog/react-natives-new-architecture-the-tricky-parts-3-4-c4638c65927c/) - [Building an AI-Powered Note-Taking App in React Native — Part 1: Text Semantic Search](https://swmansion.com/blog/building-an-ai-powered-note-taking-app-in-react-native-part-1-text-semantic-search-3f3c94a2f92b/) - [React Native for Vega: Recreating Apple & Google Photos in RN — Part 3](https://swmansion.com/blog/react-native-for-vega-recreating-apple-google-photos-in-rn-part-3-f015e9272aed/) - [Onboarding in React Native Doesn’t Have to Be Hard](https://swmansion.com/blog/onboarding-in-react-native-doesnt-have-to-be-hard-d037cd383771/) - [How to Add Meta Quest Support to Your Expo App](https://swmansion.com/blog/how-to-add-meta-quest-support-to-your-expo-app-68c52778b1fe/) - [Amazon x Software Mansion: Powering Vega OS with React Native](https://swmansion.com/blog/amazon-x-software-mansion-powering-vega-os-with-react-native-75c4cf522fd7/) - [Setting up GitHub SSH Key on Expo EAS](https://swmansion.com/blog/setting-up-github-ssh-key-on-expo-eas-e678c134bf3f/) - [React Native New Architecture: Key Performance Boosts](https://swmansion.com/blog/react-native-new-architecture-key-performance-boosts-4ce68cc3cc9f/) - [Winter Internship 2026 at Software Mansion](https://swmansion.com/blog/winter-internship-2026-at-software-mansion-7778f05d1c57/) - [Real-Time Audio Transcription API: How to Turn Speech to Text During Live Conferencing](https://swmansion.com/blog/real-time-audio-transcription-api-how-to-turn-speech-to-text-during-live-conferencing-f77e2ff3f4de/) - [Why Did My App Stop Working After Upgrading to the New Architecture?](https://swmansion.com/blog/why-did-my-app-stop-working-after-upgrading-to-the-new-architecture-f9e45406d6a9/) - [Building a Spotify Clone in React Native](https://swmansion.com/blog/building-a-spotify-clone-in-react-native-c1284b3a86ed/) - [React Conf 2025 — Recap](https://swmansion.com/blog/react-conf-2025-recap-922c50d97318/) - [Welcoming the Next Generation of Hermes](https://swmansion.com/blog/welcoming-the-next-generation-of-hermes-67ab5679e184/) - [WebRTC vs HLS — Which One Is Better for Your Streaming Project?](https://swmansion.com/blog/webrtc-vs-hls-which-one-is-better-for-your-streaming-project-0e724ed6fe10/) - [Building Fully Native iOS Apps with Expo EAS](https://swmansion.com/blog/building-fully-native-ios-apps-with-expo-eas-760b5480d7c5/) - [FFmpeg Alternative: 3 Years Ago, We Didn’t Know How to Do Live Video Mixing](https://swmansion.com/blog/ffmpeg-alternative-3-years-ago-we-didnt-know-how-to-do-live-video-mixing-fc38829c412e/) - [The Best AI Agent Frameworks](https://swmansion.com/blog/the-best-ai-agent-frameworks-5aea3d8c5d93/) - [React Native Multiplatform: Recreating Apple & Google Photos in React Native — Part 2](https://swmansion.com/blog/react-native-multiplatform-recreating-apple-google-photos-in-react-native-part-2-832398eb0d4c/) - [Retrieval-Augmented Generation Explained](https://swmansion.com/blog/retrieval-augmented-generation-explained-840cbd744c99/) - [Top 6 Local AI Models for Maximum Privacy and Offline Capabilities](https://swmansion.com/blog/top-6-local-ai-models-for-maximum-privacy-and-offline-capabilities-888160243a94/) - [Reanimated 4 Stable Release — the Future of React Native Animations](https://swmansion.com/blog/reanimated-4-stable-release-the-future-of-react-native-animations-ba68210c3713/) - [Popcorn: Bringing Elixir to the Browser](https://swmansion.com/blog/popcorn-bringing-elixir-to-the-browser-8993a58a00be/) - [React Native Image List: Recreating Apple & Google Photos in React Native — Part 1](https://swmansion.com/blog/react-native-image-list-recreating-apple-google-photos-in-react-native-part-1-7f73fb74fc63/) - [Introducing react-native-wallet: The Cross-Platform Way to Add Cards to Apple & Google Wallet](https://swmansion.com/blog/introducing-react-native-wallet-90c1ee103d3e/) - [Building Interactive Streaming Apps: WebRTC, WHIP & WHEP Explained](https://swmansion.com/blog/building-interactive-streaming-apps-webrtc-whip-whep-explained-d38f4825ec90/) - [Introducing React Native RAG: Local & Offline Retrieval-Augmented Generation](https://swmansion.com/blog/introducing-react-native-rag-fbb62efa4991/) - [Best React Native Debugging Tools in 2025](https://swmansion.com/blog/best-react-native-debugging-tools-in-2025-a95dcac7a014/) - [Real-Time Gesture Recognition in Videoconferencing](https://swmansion.com/blog/real-time-gesture-recognition-in-videoconferencing-4711855a1a53/) - [WebRTC: P2P, SFU, MCU and All You Need to Know About Them](https://swmansion.com/blog/webrtc-p2p-sfu-mcu-and-all-you-need-to-know-about-them-596b6ccb6ddf/) - [React Native ExecuTorch — release v0.4.0](https://swmansion.com/blog/react-native-executorch-release-v0-4-0-262d4013ac10/) - [Elixir Contributor Summit 2025: Shaping the Future Together at Software Mansion](https://swmansion.com/blog/elixir-contributor-summit-2025-shaping-the-future-together-at-software-mansion-cc3271a188eb/) - [How to Build a Custom React Renderer?](https://swmansion.com/blog/how-to-build-a-custom-react-renderer-595dc4a9cb1c/) - [What’s New in LiveDebugger v0.2.0?](https://swmansion.com/blog/whats-new-in-livedebugger-v0-2-0-4543d3af5486/) - [Optimizing Mobile App Battery Usage & Crash Rate (Based on a True Story)](https://swmansion.com/blog/optimizing-battery-usage-improving-crash-free-rate-in-a-react-native-app-9e80ba1f240a/) - [Offline Text Recognition on Mobile: How We Brought EasyOCR to React Native ExecuTorch](https://swmansion.com/blog/bringing-easyocr-to-react-native-executorch-2401c09c2d0c/) - [You Might Not Need react-native-svg](https://swmansion.com/blog/you-might-not-need-react-native-svg-b5c65646d01f/) - [Type Safety in WebGPU Applications: The TypeGPU Approach](https://swmansion.com/blog/type-safety-in-webgpu-applications-the-typegpu-approach-5df019ac6a61/) - [React & Live Streaming: How to Include Video Mixing in Your App](https://swmansion.com/blog/react-live-streaming-how-to-include-video-mixing-in-your-app-c460e09da7a8/) - [Introduction to LiveDebugger: A Tool for Debugging Phoenix LiveView Apps](https://swmansion.com/blog/introduction-to-livedebugger-a-tool-for-debugging-phoenix-liveview-apps-bf7e56ab00fb/) - [Introducing Telemetry Tracing in membrane_core v1.2](https://swmansion.com/blog/introducing-telemetry-and-tracing-for-membrane-components-da76a8b00d90/) - [How React Native Reanimated Updates the Styles — a Deep Dive](https://swmansion.com/blog/how-react-native-reanimated-updates-the-styles-a-deep-dive-338ab22e9f21/) - [Summer Internship 2025 at Software Mansion](https://swmansion.com/blog/summer-internship-2025-at-software-mansion-dd81f1b0c4b8/) - [State of React Native 2024: Our Key Takeaways](https://swmansion.com/blog/wstate-of-react-native-2024-our-key-takeaways-19a7c0039d36/) - [Elixir for Multimedia: A Practical Guide for Developers](https://swmansion.com/blog/elixir-for-multimedia-a-practical-guide-for-developers-169adb0eb523/) - [Building a Membrane Pipeline to Talk to Google Gemini](https://swmansion.com/blog/building-a-membrane-pipeline-to-talk-to-google-gemini-ff637fc0fe40/) - [Hooking into Erlang’s SSL to Perform DTLS-SRTP Handshake](https://swmansion.com/blog/hooking-into-erlangs-ssl-to-perform-dtls-srtp-handshake-2b1cb679f4a6/) - [Introducing React Native Audio API](https://swmansion.com/blog/hello-react-native-audio-api-bb0f10347211/) - [Building a Globally Distributed WebRTC Service with Elixir WebRTC, STUNner, and Cilium Cluster Mesh](https://swmansion.com/blog/building-a-globally-distributed-webrtc-service-with-elixir-webrtc-stunner-and-cilium-cluster-mesh-54553bc066ad/) - [Reanimated 4 is new, but also very familiar](https://swmansion.com/blog/reanimated-4-is-new-but-also-very-familiar-b926dd59aa40/) - [A Year in Review: 2024 at Software Mansion Multimedia & AI Teams](https://swmansion.com/blog/a-year-in-review-2024-at-software-mansion-multimedia-ai-teams-cb02881b1cb7/) - [Add React Native to the Signal open source app — part 2 (Android)](https://swmansion.com/blog/add-react-native-to-the-signal-open-source-app-part-2-android-803c1b726582/) - [Elixir Stream Week: how NOT to load test during a live Elixir-run broadcast watched by hundreds of…](https://swmansion.com/blog/elixir-stream-week-how-not-to-load-test-during-a-live-elixir-run-broadcast-watched-by-hundreds-of-217d8f4b957a/) - [Introducing React Native Screens 4.0.0](https://swmansion.com/blog/introducing-react-native-screens-4-0-0-1b833ff98a55/) - [Add React Native to the Signal open source app — part 1 (iOS)](https://swmansion.com/blog/add-react-native-to-the-signal-open-source-app-part-1-ios-ffb61819031e/) - [Introducing React Native ExecuTorch](https://swmansion.com/blog/introducing-react-native-executorch-2bdb87592884/) - [Live Streaming with React — More Rust in the JavaScript Ecosystem](https://swmansion.com/blog/live-streaming-with-react-more-rust-in-the-javascript-ecosystem-f83a0371e16c/) - [Winter Internship 2025 at Software Mansion](https://swmansion.com/blog/winter-internship-2025-at-software-mansion-b413ad7847f4/) - [React Native’s New Architecture: The Tricky Parts (1/4)](https://swmansion.com/blog/react-natives-new-architecture-the-tricky-parts-1-2-bb0c16950f2d/) - [React Native’s New Architecture: The Tricky Parts (2/4)](https://swmansion.com/blog/react-natives-new-architecture-the-tricky-parts-2-2-ac5f2adf22ec/) - [Introducing react-native-whip-whep](https://swmansion.com/blog/introducing-react-native-whip-whep-ac9e5588d4da/) - [RTC.ON behind the scenes](https://swmansion.com/blog/rtc-on-behind-the-scenes-60f5ddfff65d/) - [Can we make CI setup simpler in React Native?](https://swmansion.com/blog/the-fastest-way-to-set-up-ci-for-a-react-native-project-4fb49c4428f1/) - [React Native IDE is now Radon IDE](https://swmansion.com/blog/react-native-ide-is-now-radon-ide-cfbdad77d43c/) - [Data channels in Elixir WebRTC](https://swmansion.com/blog/data-channels-in-elixir-webrtc-0853c7d0e256/) - [Boombox — a simple streaming library on top of Membrane](https://swmansion.com/blog/boombox-a-simple-streaming-library-on-top-of-membrane-307649c09d63/) - [EraserAI — How to create efficient app for edge device?](https://swmansion.com/blog/eraserai-how-to-create-efficient-app-for-edge-device-04f09aa8072f/) - [Elixir WebRTC — batteries included WebRTC implementation for the Elixir ecosystem](https://swmansion.com/blog/elixir-webrtc-batteries-included-webrtc-implementation-for-the-elixir-ecosystem-249eff4073d8/) - [Exporting AI models on Android with XNNPACK and ExecuTorch](https://swmansion.com/blog/exporting-ai-models-on-android-with-xnnpack-and-executorch-3e70cff51c59/) - [Bringing native AI to your mobile apps with ExecuTorch — part II — Android](https://swmansion.com/blog/bringing-native-ai-to-your-mobile-apps-with-executorch-part-ii-android-29431b6b9f7f/) - [11 resources that will help you start with WebRTC](https://swmansion.com/blog/11-resources-that-will-help-you-start-with-webrtc-b7e48c178b76/) - [On-device AI/ML in React Native](https://swmansion.com/blog/on-device-ai-ml-in-react-native-137918d0331b/) - [Bringing native AI to your mobile apps with ExecuTorch— part I — iOS](https://swmansion.com/blog/bringing-native-ai-to-your-mobile-apps-with-executorch-part-i-ios-f1562a4556e8/) - [Introducing ExVision](https://swmansion.com/blog/introducing-exvision-ebf799bef1b2/) - [The second release of Elixir WebRTC](https://swmansion.com/blog/the-second-release-of-elixir-webrtc-3e6358089455/) - [Sunrising New Architecture in the New Expensify App](https://swmansion.com/blog/sunrising-new-architecture-in-the-new-expensify-app-729d237a02f5/) - [Software Mansion Hackathon 2024](https://swmansion.com/blog/software-mansion-hackathon-2024-677594b46e2c/) - [Not all who wander are lost](https://swmansion.com/blog/not-all-who-wander-are-lost-805811c433c5/) - [How to Handle DynamoDB Streams the Easy Way in Typescript](https://swmansion.com/blog/how-to-handle-dynamodb-streams-the-easy-way-in-typescript-ff870f370310/) - [Building an AI-Powered Audio Interface: Our Journey and Insights](https://swmansion.com/blog/building-an-ai-powered-audio-interface-our-journey-and-insights-49541f8c2fe0/) - [Summer Internship 2024 at Software Mansion](https://swmansion.com/blog/summer-internship-2024-at-software-mansion-93f7c0651ada/) - [Non-technical Graduate Program 2024](https://swmansion.com/blog/non-technical-graduate-program-2024-9f7dd094b665/) - [Pushing the Boundaries with Real-Time Video Inpainting](https://swmansion.com/blog/pushing-the-boundaries-with-real-time-video-inpainting-35cd82c624fb/) - [Introducing Elixir WebRTC](https://swmansion.com/blog/introducing-elixir-webrtc-a37ece4bfca1/) - [How React Native Screens powers Expo Router?](https://swmansion.com/blog/how-react-native-screens-powers-expo-router-766480fd2d06/) - [Deep-flatten TypeScript type](https://swmansion.com/blog/deep-flatten-typescript-type-c0d123028d82/) - [Effective Starknet Contract Testing with Starknet Foundry](https://swmansion.com/blog/effective-starknet-contract-testing-with-starknet-foundry-315ccc55d24f/) - [Winter Internship 2024 at Software Mansion](https://swmansion.com/blog/winter-internship-2024-at-software-mansion-be201ab17eb6/) - [Client side AI model inference for real-time video processing — style transfer](https://swmansion.com/blog/client-side-ai-model-inference-for-real-time-video-processing-style-transfer-52be282968f9/) - [Modeling with DynamoDB made easy in Typescript](https://swmansion.com/blog/modeling-with-dynamodb-made-easy-in-typescript-cdada092d387/) - [Introducing the Membrane Bot: Revolutionizing Technical Support with Conversational AI](https://swmansion.com/blog/introducing-the-membrane-bot-revolutionizing-technical-support-with-conversational-ai-2a9e67cdf57f/) - [Realtime object detection — fine-tuning and deploying models for processing video streams](https://swmansion.com/blog/realtime-object-detection-fine-tuning-and-deploying-models-for-processing-video-streams-312f068dbf88/) - [Non-technical Graduate Program 2023](https://swmansion.com/blog/non-technical-graduate-program-2023-ae67f6127969/) - [Summer 2023 Internship at Software Mansion](https://swmansion.com/blog/summer-2023-internship-at-software-mansion-97dc515260d3/) - [Releasing Reanimated 3.0](https://swmansion.com/blog/releasing-reanimated-3-0-17fab4cb2394/) - [Creating an Android Application With Starknet-JVM and Jetpack Compose](https://swmansion.com/blog/creating-an-android-application-with-starknet-jvm-and-jetpack-compose-55f08dea5faa/) - [Summary of 2022 — React Native Open Source at Software Mansion](https://swmansion.com/blog/summary-of-2022-react-native-open-source-at-software-mansion-9edf929db005/) - [Say hello to Scarb, a Cairo 1.0 package manager](https://swmansion.com/blog/say-hello-to-scarb-a-cairo-1-0-package-manager-782b0321f82f/) - [EIP712 authentication in Cairo](https://swmansion.com/blog/eip712-authentication-in-cairo-9d19e7ea273a/) - [Winter Internship 2023 at Software Mansion](https://swmansion.com/blog/winter-internship-2023-at-software-mansion-7ba9ecaf06f5/) - [Testing StarkNet contracts made easy with Protostar](https://swmansion.com/blog/testing-starknet-contracts-made-easy-with-protostar-2ecdad3c9133/) - [Announcing Reanimated 3](https://swmansion.com/blog/announcing-reanimated-3-16167428c5f7/) - [Introducing Fabric to react-native-screens](https://swmansion.com/blog/introducing-fabric-to-react-native-screens-fd17bf18858e/) - [Summer 2022 Internship at Software Mansion](https://swmansion.com/blog/summer-2022-internship-at-software-mansion-e246e5e56db5/) - [App.js Conf 2022](https://swmansion.com/blog/app-js-conf-2022-4ad792c0a566/) - [Introduction to manual gestures and touch events](https://swmansion.com/blog/introduction-to-manual-gestures-and-touch-events-a1dde7c98612/) - [How to Build and Distribute Any React Native App With New Expo Services](https://swmansion.com/blog/how-to-build-and-distribute-any-react-native-app-with-new-expo-services-529a56cec852/) - [Introducing Gesture Handler 2.0](https://swmansion.com/blog/introducing-gesture-handler-2-0-50515f1c4afc/) - [Experimenting with React Freeze](https://swmansion.com/blog/experimenting-with-react-freeze-71da578e2fa6/) - [Top 7 myths about Expo in 2021](https://swmansion.com/blog/top-7-myths-about-expo-in-2021-ee66f929bf9f/) - [Building Reigns: How to reign over mobile game development using Reanimated 2. Part 3](https://swmansion.com/blog/building-reigns-how-to-reign-over-mobile-game-development-using-reanimated-2-pa-55ae2017df50/) - [Building Reigns: How to strengthen reign over mobile game development using Reanimated 2.](https://swmansion.com/blog/building-reigns-how-to-strengthen-reign-over-mobile-game-development-using-reanimated-2-66c127a210e9/) - [Building Reigns: How to reign over mobile game development using Reanimated 2.](https://swmansion.com/blog/reanimated-2-the-game-9402622c1fe5/) - [iCalendar, CalDAV & Elixir](https://swmansion.com/blog/icalendar-caldav-elixir-13be601572eb/) - [Reanimated 2.0 stable release is out!](https://swmansion.com/blog/reanimated-2-0-stable-release-is-out-564c9c910891/) - [Summer 2021 Internship at Software Mansion](https://swmansion.com/blog/summer-2021-internship-at-software-mansion-71096461959b/) - [Reanimated 2 Events (part II) — Scroll Events](https://swmansion.com/blog/reanimated-2-events-part-ii-scroll-events-a319fd9f1e62/) - [SwiftUI renderer for React Native (Part II)](https://swmansion.com/blog/swiftui-renderer-for-react-native-part-ii-161bad1d69e1/) - [SwiftUI renderer for React Native](https://swmansion.com/blog/swiftui-renderer-for-react-native-2b62fda38c9b/) - [Reanimated 2 Events](https://swmansion.com/blog/reanimated-2-events-5bf09d1c8678/) - [Controlling and Customizing Animations in Reanimated 2](https://swmansion.com/blog/controlling-and-customizing-animations-in-reanimated-2-cee2d5d21285/) - [Build and publish multiple RN apps from the same codebase. (part III)](https://swmansion.com/blog/build-and-publish-multiple-rn-apps-from-the-same-codebase-part-iii-4cb3d1d33bbe/) - [Build and publish multiple RN apps from the same codebase. (part II)](https://swmansion.com/blog/build-and-publish-multiple-rn-apps-from-the-same-codebase-part-ii-815d0fffc222/) - [Shared Values in Reanimated 2](https://swmansion.com/blog/shared-values-in-reanimated-2-af0cb4ffe24/) - [Build and publish multiple RN apps from the same codebase.](https://swmansion.com/blog/build-and-publish-multiple-rn-apps-from-the-same-codebase-29bf3bc54f7f/) - [Introducing Reanimated 2](https://swmansion.com/blog/introducing-reanimated-2-752b913af8b3/) - [Styles & Theming in React Native — a snatch from the webinar.](https://swmansion.com/blog/styles-theming-in-react-native-a-snatch-from-the-webinar-93a26698dce6/) - [Software Mansion Academy](https://swmansion.com/blog/software-mansion-academy-1aac5c1ef245/) - [Live video streaming in Elixir made simple with Membrane](https://swmansion.com/blog/live-video-streaming-in-elixir-made-simple-with-membrane-fc5b2083982d/) ## Changelog - [Boombox](https://swmansion.com/changelog/boombox/) - [cairo-coverage](https://swmansion.com/changelog/cairo-coverage/) - [cairo-lint](https://swmansion.com/changelog/cairo-lint/) - [CairoLS](https://swmansion.com/changelog/cairols/) - [cairo-profiler](https://swmansion.com/changelog/cairo-profiler/) - [Detour](https://swmansion.com/changelog/detour/) - [Elixir WebRTC](https://swmansion.com/changelog/elixir-webrtc/) - [expo-horizon](https://swmansion.com/changelog/expo-horizon/) - [expo-live-activity](https://swmansion.com/changelog/expo-live-activity/) - [Fishjam](https://swmansion.com/changelog/fishjam/) - [kmp-maps](https://swmansion.com/changelog/kmp-maps/) - [kmp-sharing](https://swmansion.com/changelog/kmp-sharing/) - [Live Debugger](https://swmansion.com/changelog/live-debugger/) - [Membrane Framework](https://swmansion.com/changelog/membrane-framework/) - [Popcorn](https://swmansion.com/changelog/popcorn/) - [Private Mind](https://swmansion.com/changelog/private-mind/) - [Radon IDE](https://swmansion.com/changelog/radon-ide/) - [react-freeze](https://swmansion.com/changelog/react-freeze/) - [react-native-audio-api](https://swmansion.com/changelog/react-native-audio-api/) - [react-native-enriched-html](https://swmansion.com/changelog/react-native-enriched-html/) - [react-native-enriched-markdown](https://swmansion.com/changelog/react-native-enriched-markdown/) - [react-native-executorch](https://swmansion.com/changelog/react-native-executorch/) - [react-native-gesture-handler](https://swmansion.com/changelog/react-native-gesture-handler/) - [react-native-onboarding](https://swmansion.com/changelog/react-native-onboarding/) - [react-native-rag](https://swmansion.com/changelog/react-native-rag/) - [react-native-reanimated](https://swmansion.com/changelog/react-native-reanimated/) - [react-native-screens](https://swmansion.com/changelog/react-native-screens/) - [react-native-shine](https://swmansion.com/changelog/react-native-shine/) - [react-native-svg](https://swmansion.com/changelog/react-native-svg/) - [react-native-whip-whep](https://swmansion.com/changelog/react-native-whip-whep/) - [react-native-worklets](https://swmansion.com/changelog/react-native-worklets/) - [Scarb](https://swmansion.com/changelog/scarb/) - [Smelter](https://swmansion.com/changelog/smelter/) - [starknet-jvm](https://swmansion.com/changelog/starknet-jvm/) - [starknet.py](https://swmansion.com/changelog/starknet-py/) - [starknet-rust](https://swmansion.com/changelog/starknet-rust/) - [starknet.swift](https://swmansion.com/changelog/starknet-swift/) - [TypeGPU](https://swmansion.com/changelog/typegpu/) - [TypeGPU Confetti](https://swmansion.com/changelog/typegpu-confetti/) - [vk-video](https://swmansion.com/changelog/vk-video/) ## Careers - [Software Engineer](https://swmansion.com/careers/software-engineer/) - [QA Automation Engineer](https://swmansion.com/careers/qa-automation-engineer/) - [Project Manager](https://swmansion.com/careers/project-manager/) - [Junior Project Manager](https://swmansion.com/careers/junior-pm/) ## Company - [Contact](https://swmansion.com/contact/): projects@swmansion.com - [Careers](https://swmansion.com/careers/): careers@swmansion.com - [Products](https://swmansion.com/products/) - [Blog](https://swmansion.com/blog/) - [Case studies](https://swmansion.com/case-studies/) - [Changelog](https://swmansion.com/changelog/) - [Investor relations](https://ir.swmansion.com): investors@swmansion.com --- # Built by Software Mansion, used by millions of developers We believe the best tools are born from conversation. By staying connected with the community and developers, we understand their needs and challenges. With a team of 375+ skilled engineers on board, we simply know how to build libraries and tools that actually make developers’ work easier. ## React Native We are the creators of core React Native libraries used by developers around the world. We had taken part in building the framework even before it became open source, shaping the ecosystem from the start. - [Learn more about React Native](https://swmansion.com/blog/?category=React+Native) ## React Native Reanimated The go-to library for building animations in React Native. Reanimated powers most React Native apps out there. - [Documentation](https://docs.swmansion.com/react-native-reanimated) - [GitHub](https://github.com/software-mansion/react-native-reanimated) ## React Native Gesture Handler It brings the native platform’s touch and gesture system to React Native through a simple, declarative API. - [Documentation](https://docs.swmansion.com/react-native-gesture-handler) - [GitHub](https://github.com/software-mansion/react-native-gesture-handler) ## Expo A full-stack React Native framework with cloud services that speed up every stage of app development. We are behind major parts of Expo SDK. We build Expo libraries for brownfield integration, live activities, Meta Quest, and more. - [Documentation](https://docs.expo.dev/) - [GitHub](https://github.com/expo/expo) ## Detour A developer-first library for deferred deep links that resolves context across installs, preserves parameters, and gets users to the right screen without extra setup. - [Documentation](https://docs.swmansion.com/detour/) - [Github](https://github.com/software-mansion-labs/react-native-detour/) ## React Native Audio API The library lets you build powerful in-app audio features like real-time visualization, multi-track playback, and more. - [Documentation](https://docs.swmansion.com/react-native-audio-api) - [GitHub](https://github.com/software-mansion/react-native-audio-api) ## React Native Screens It provides native navigation primitives for React Native apps. Our library powers React Navigation and Expo Router. - [Documentation](https://docs.swmansion.com/react-native-screens) - [GitHub](https://github.com/software-mansion/react-native-screens) ## React Native SVG - [Documentation](https://docs.expo.dev/versions/latest/sdk/svg) - [GitHub](https://github.com/software-mansion/react-native-svg) ## React Native Wallet The library simplifies adding payment cards to Google and Apple Wallet with a ready-to-use component. - [GitHub](https://github.com/Expensify/react-native-wallet) ## React Navigation - [Documentation](https://reactnavigation.org/) - [GitHub](https://github.com/react-navigation/react-navigation) ## Pulsar Ready-to-use haptic presets, a pattern composer for custom haptic sequences, and a real-time composer for gesture-driven feedback. - [Documentation](https://docs.swmansion.com/pulsar/) - [Github](https://github.com/software-mansion/pulsar) ## React Native Shine A fast and efficient way to add interactive GPU-based shader effects to your React Native apps using TypeGPU and WebGPU. - [GitHub](https://github.com/software-mansion-labs/react-native-shine) ## React Native Enriched React Native Enriched is a family of HTML, markdown, and text streaming packages that let you enrich your app with truly native React Native components for rich text rendering and editing. - [Documentation](https://enriched.swmansion.com/) - [Github](https://github.com/software-mansion/react-native-enriched-html) ## Simcam The Mac app that lets you stream your camera into the iOS Simulator to test scanning, image recognition, and capture features without a physical device. - [See more](https://simcam.swmansion.com/) ## React Native Bottom Sheet It provides native bottom sheet components for React Native, letting you build inline and modal sheets with fully custom content, dynamic sizing, smooth native gestures, and more. - [GitHub](https://github.com/software-mansion-labs/react-native-bottom-sheet) ## Radon The VSCode and Cursor extension that turns your editor into a complete IDE for React Native and Expo development. - [Documentation](https://radon.swmansion.com/) - [GitHub](https://github.com/software-mansion/radon-ide) ## React Native Worklets The library makes it possible to run JavaScript code in parallel across multiple threads and runtimes, boosting app performance. - [Documentation](https://docs.swmansion.com/react-native-worklets) - [GitHub](https://github.com/software-mansion/react-native-reanimated/tree/main/packages/react-native-worklets) ## Smelter Our tool for low-latency live video mixing. It is perfect for streaming, broadcasting, and video conferencing. - [Documentation](https://smelter.dev/) - [GitHub](https://github.com/software-mansion/smelter) ## Multimedia & RTC We have become experts in developing multimedia and WebRTC tools and frameworks. We have created advanced streaming platforms, multimedia frameworks, and video mixers. - [Learn more about Multimedia](https://swmansion.com/blog/?category=Multimedia) ## TypeGPU The library that enhances the WebGPU API, enabling type-safe, declarative resource management. - [Documentation](https://docs.swmansion.com/TypeGPU) - [GitHub](https://github.com/software-mansion/TypeGPU) ## Fishjam Real-time media platform powering video conferencing, interactive streaming, AI voice agents, and video compositing. - [Documentation](https://fishjam.swmansion.com/docs/) - [GitHub](https://github.com/fishjam-dev/fishjam) ## gpu-video Our open-source rust library for intuitive and painless cross-platform hardware video decoding and encoding - [GitHub](https://github.com/software-mansion/smelter/tree/master/gpu-video) ## Membrane The versatile multimedia streaming and processing framework that lets you build media servers tailored to your needs. - [Documentation](https://membrane.stream/) - [GitHub](https://github.com/membraneframework) ## Elixir Libraries We started working with the Elixir language when building the Membrane framework. Since then, we have been active in the community, working on debugging tools, browser integration solutions, and WebRTC implementations. - [Learn more about Elixir](https://globalelixirmeetups.com/) ## Live Debugger Our browser-based tool for debugging LiveView apps, 
built to improve the Elixir developer experience. - [Documentation](https://docs.swmansion.com/live-debugger) - [GitHub](https://github.com/software-mansion/live-debugger) ## Popcorn The library that brings Elixir to the browser. It lets you call functions, spawn processes, and compile code on the client side. - [Documentation](https://popcorn.swmansion.com/) - [GitHub](https://github.com/software-mansion/popcorn) ## Elixir WebRTC The WebRTC implementation for the Elixir ecosystem. It is easy to use with Phoenix, Membrane, or Elixir Nx. - [Documentation](https://elixir-webrtc.org/) - [GitHub](https://github.com/elixir-webrtc) ## Argent An agentic toolkit to control, debug, and profile iOS and Android applications. Your agent can navigate your app, explore the component tree, inspect network requests, and trace performance problems in your mobile apps. - [See more](https://argent.swmansion.com) ## AI We first used AI to develop software for removing objects from live video feeds. That’s how we began working on low-latency video AI. Now, we build tools that run LLMs locally, keeping data secure and private. - [Learn more about AI](https://swmansion.com/blog/?category=AI) ## React Native Executorch The library that lets you run LLMs and AI models fully on-device, with a declarative API powered by ExecuTorch. - [Documentation](https://docs.swmansion.com/react-native-executorch) - [GitHub](https://github.com/software-mansion/react-native-executorch) ## Private Mind The fully offline AI chat app that showcases what is possible with React Native RAG and React Native ExecuTorch. - [Documentation](https://privatemind.swmansion.com/) - [GitHub](https://github.com/software-mansion-labs/private-mind) ## React Native RAG Our on-device RAG library that offers full privacy and offline capability. You can use it to supercharge LLMs with your local knowledge base. - [Documentation](https://software-mansion-labs.github.io/react-native-rag) - [GitHub](https://github.com/software-mansion-labs/react-native-rag) ## Blockchain We build developer tools for blockchain ecosystems. 
Our projects provide infrastructure for smart contract development and package management, supporting developers who work on decentralized networks. - [Learn more about Blockchain](https://swmansion.com/blog/?category=Other) ## Scarb The build toolchain and package manager for Cairo and Starknet ecosystems. - [Documentation](https://docs.swmansion.com/scarb) - [GitHub](https://github.com/software-mansion/scarb) ## Starknet Foundry The toolchain for creating, testing, and deploying smart contracts on the Starknet network. - [Documentation](https://foundry-rs.github.io/starknet-foundry/) - [GitHub](https://github.com/foundry-rs/starknet-foundry) --- # Let’s build something great together We like working on extraordinary software. Tell us about your project and let’s find out if we have a match. ## Get in touch Email: projects@swmansion.com ## Departments - **Careers**: careers@swmansion.com - **Investors**: investors@swmansion.com - **Press & Media**: media@swmansion.com - **Events**: events@swmansion.com ## Profiles ### Software Mansion - [Twitter](https://twitter.com/swmansion) - [YouTube](https://youtube.com/@SoftwareMansion) - [Facebook](https://facebook.com/SoftwareMansion) - [LinkedIn](https://linkedin.com/company/software-mansion) - [Instagram](https://instagram.com/swmansion) - [Dribbble](https://dribbble.com/softwaremansion) - [Software Mansion](https://github.com/software-mansion) - [Software Mansion Labs](https://github.com/software-mansion-labs) ### Membrane - [Twitter](https://twitter.com/elixirmembrane) - [Discord](https://discord.gg/nwnfVSY) - [Membrane Framework](https://github.com/membraneframework) - [Membrane Frameworks Labs](https://github.com/membraneframework-labs) ### App.js Conference - [Twitter](https://x.com/appjsconf) - [Youtube](https://www.youtube.com/@SoftwareMansion) --- # React Native New Architecture Migration Migrate your React Native app to the New Architecture with engineers who work on React Native, Expo, and the libraries your app depends on. Why migrate now ### The New Architecture is becoming the default path for React Native teams Migration is no longer just a technical preference. It affects framework support, library compatibility, performance, and your ability to keep shipping on current React Native versions. ### Expo SDK 53 defaults to the New Architecture Expo has already moved the default development path toward the New Architecture. ### Meta recommends migration React Native's maintainers are steering teams toward the New Architecture as the supported future. ### More libraries are New Architecture-only Delaying migration increases the risk that dependencies block framework upgrades or product work. ### Most apps have already moved The original page cites 75% of React Native apps as already migrated, which makes migration less exceptional and more expected. ### The Old Architecture window is closing RN 0.81 is listed as the last React Native version with the Old Architecture included. How migration helps ### Move forward without turning the upgrade into product drag We handle the migration across React Native core, dependencies, native modules, build setup, and release requirements so your team can keep building product features. ### Keep your app fast The New Architecture uses significantly less memory in scenarios like long-list scrolling, and we help you avoid third-party breakages that can silently hurt reliability. ### Use New Architecture-only features We prepare your codebase for TurboModules, Concurrent React, bridgeless mode, synchronous rendering, type safety, lazy module loading, and newer React Native capabilities. ### Reduce security risk Outdated React Native versions stop receiving fixes. We update dependencies, patch vulnerabilities, and move your app onto supported foundations. ### Cut technical debt early The longer migration waits, the harder it becomes. We deal with core upgrades, dependencies, native modules, and build setup before they turn into rewrites. ### Keep releases smooth We handle SDK bumps, policy updates, and platform compliance so App Store and Play Store changes do not create avoidable release delays. ### Improve UX and DX The migration unlocks modern APIs, better tooling, and new capabilities that help your team ship responsive, performant experiences. Why Software Mansion ### React Native migration work is close to our daily work We are not approaching the New Architecture from the outside. We work on React Native, Expo, open source libraries, and real migrations across production apps. ### React Native and Expo contributors We are core contributors to React Native and one of the top contributing groups in the Expo ecosystem. ### 30+ libraries migrated We have migrated 30+ core React Native libraries and a dozen mobile apps to the New Architecture. ### App.js Conf organizers The biggest React Native and Expo-focused conference brings together experts from companies like Meta, Microsoft, Shopify, and Amazon. ### Maintainers of key libraries Reanimated, Gesture Handler, Screens, and other key React Native libraries are created and maintained by Software Mansion engineers. ### Open source as daily work About 30% of our daily work is devoted to open source, which keeps us close to ecosystem changes that affect React Native teams. Performance proof ### React Native New Architecture: key performance boosts Our engineers have documented where the New Architecture improves performance and what teams need to account for when adopting it. Read the post ### React Native New Architecture: Key Performance Boosts Deep implementation knowledge ### React Native's New Architecture: the tricky parts The Tricky Parts series covers the implementation details teams run into when moving beyond the high-level migration checklist. Read the series ### React Native’s New Architecture: The Tricky Parts (3/4) Migration support ### Ready to migrate without slowing the product roadmap? Share your current React Native version, dependency constraints, and release timeline. We'll help you scope the safest path to the New Architecture. Talk to our team ## Contact Email projects@swmansion.com or use https://swmansion.com/contact/ --- # React Native Performance Optimization Performance audits, hands-on remediation, and expert React Native consulting from React Foundation founding members and core contributors. Reasons to trust ### We don't just consult on React Native. We build it. Most performance consultants work only from the outside: reading docs, running profilers, and making guesses. Our engineers have been shaping React Native itself and building the open-source libraries used by most production apps. That means we know what is happening under the hood, not just what the tools report. ### 2,500+ pull requests to the Expo ecosystem We stay close to the framework internals by contributing where teams actually ship React Native code. ### React Foundation founding member We help shape the future of the framework alongside Meta, Vercel, and Expo. ### 2.5M+ weekly npm downloads Each of our leading React Native libraries is part of the ecosystem's production infrastructure. ### 10+ years contributing to React Native core and infrastructure We have built deep expertise by helping maintain the tools and libraries teams depend on every day. How we can help you ### Audit & consulting modes We can diagnose the problem, fix it directly in your codebase, or work side by side with your team to transfer the knowledge. ### Performance audit We profile your app on real devices, instrument your codebase, and deliver a prioritized report on startup time, rerender cycles, bundle modes, memory pressure, battery behavior, and more. You'll know exactly what to fix and in what order. Typical turnaround: 2–4 weeks. ### Hands-on remediation We find the issues and fix them directly in your codebase. Battery drain from background rerenders, problems with gesture handling, or crashes tied to native module threading – we've seen all of it, we know where to look, and we know how to fix it in days, not weeks. ### Expert help We pair your engineers with our senior developers for a few days, bringing our tooling and our knowledge of the framework internals so your team understands why the issues appeared and how to prevent them from coming back. Proof in production ### We fix the problems standard profiling often misses SeaPeople came to us with stability and performance issues that needed more than surface-level debugging. We tracked down the hidden rerender loop behind CPU spikes and battery drain, improved the app's crash-free rate, and helped the team move faster on both platforms. ### Optimized battery usage and UX of a boating community app App of the Day on App Store in 2025 Crash-free rate achieved in just three months 99% Read the case study What clients say ### Trusted by teams shipping serious React Native products When performance issues start hurting real users, teams come to us for direct help from engineers who know the framework from the inside. Being so well connected in the React Native community and supporting key open source projects, we know Software Mansion is always up on the latest developments. The effort to make our app fast on both platforms was beyond our skillset. The team at SM jumped in, onboarded very quickly, and made an impact right away. Learn how we think ### Best React Native debugging tools in 2025 Read a practical guide by the engineer who built Radon IDE and see how we think about profiling setup, the new DevTools stack, and catching the issues standard tooling misses. Browse our React Native insights ### Best React Native Debugging Tools in 2025 ## Contact Email projects@swmansion.com or use https://swmansion.com/contact/ --- # React Native Brownfield Integration Add React Native to your existing native app with the engineers who built expo-brownfield, now part of the official Expo SDK. Why Software Mansion ### Our brownfield library is now part of the Expo SDK We created and upstreamed expo-brownfield – the official Expo package for adding React Native to existing native apps. Expo shipped it as part of SDK 55. When we help you with brownfield integration, we work in tooling we understand under the hood. ### 10+ years contributing to React Native core Deep framework knowledge built through years of active contribution, not just usage. ### 2,500+ pull requests to the Expo ecosystem We stay close to where teams actually ship React Native, including brownfield projects. ### React Foundation founding member We help shape the future of the framework alongside Meta, Vercel, and Expo. ### expo-brownfield is in Expo SDK 55 The library we built to automate brownfield setup is now the approach Expo officially recommends. How we can help ### How we help with React Native brownfield integration We meet you wherever you are in the process – from first setup to ongoing maintenance. ### Brownfield setup & integration We configure the React Native runtime, set up your build pipeline, and embed React Native into your native navigation cleanly. Whether you want to run one screen in production or migrate an entire feature area, we make sure the integration fits your architecture and release process. ### Expo brownfield with isolated approach Using expo-brownfield, we can package your React Native code as a native binary artifact – XCFramework for iOS, AAR for Android – that your native team consumes like any other dependency. No React Native build dependencies, no shared toolchain; their workflow doesn't change. ### Screen migration If you already have native screens you want to move to React Native, we can write the code and handle the coordination. You end up with less duplication and one shared codebase across both iOS and Android. ### Ongoing development Migration is a process. Whether you're starting fresh or already have a brownfield setup that needs work – a React Native bump, a performance issue, a tricky integration – we can pick it up wherever you are. ### expo-brownfield is now part of the official Expo SDK The library we built to automate brownfield setup for Expo projects shipped as part of SDK 55. What started as an internal tool is now the approach Expo officially recommends. ### Brownfield integration — exploring the limits Mariusz Stanisz at App.js Conf 2024 on what happens when you push brownfield React Native beyond the basics: connecting two large standalone apps, navigating edge cases the docs don't cover, and what it actually takes to ship it. From our engineers ### Add React Native to the Signal open source app – Part 1 (iOS) Signal has years of native decisions baked in, custom build configurations, and no margin for error. This walkthrough covers what it actually takes to get React Native running inside an app like that. Read the article ### Add React Native to the Signal open source app — part 1 (iOS) What clients say ### Trusted by teams at the core of the React Native ecosystem We have grown to trust Software Mansion to the point where we have them build significant parts of our core technology alongside our own team. Our software products wouldn't be as far along today if we didn't have Software Mansion's help along the way. From our engineers ### How to add React Native to an existing Android app without a rewrite A commit-by-commit walkthrough of the integrated brownfield approach using Expo: two-way navigation between native Activities and React Native screens, Kotlin native modules, and EAS Build. Read the guide ### Building an Integrated React Native Brownfield App Using Expo: Step-by-Step Android Guide ## Contact Email projects@swmansion.com or use https://swmansion.com/contact/ --- # React Native Animations & Interactions ### We built the tools. We’ll build your animations. The libraries and infrastructure behind modern React Native motion came out of our team, so you get implementation-level expertise rather than surface-level consulting. ### Reanimated The library behind most production React Native animations came out of Software Mansion. ### Gesture Handler The standard for native-driven gesture management in React Native is also our work. ### React Native 0.85 We co-authored the new animation backend shipped in React Native 0.85 alongside Meta. ### TypeGPU Our type-safe WebGPU toolkit helps bring advanced GPU work into React Native experiences. ### 10+ years in React Native We have spent more than a decade contributing to React Native core and the ecosystem around it. ### From rough interaction ideas to production-ready motion We can debug what feels wrong, build complex animation systems from scratch, push into GPU rendering, or stay with your team as the product evolves. ### Fix what doesn’t work You might know exactly what’s wrong, but you don’t have to. We find what’s causing dropped frames, gesture conflicts, or interactions that feel off and fix it directly in your codebase. ### Animations built from scratch Whether you need a gesture-driven UI, a custom transition system, or something recreated from a design, we build and implement it end to end. ### Canvas, GPU, and shader-based rendering Using react-native-skia, react-native-wgpu, and TypeGPU, we can build interactions that are not possible with standard React Native primitives. ### Ongoing development If you need someone to extend what’s already there, handle a Reanimated upgrade, or keep up with React Native releases, we can stay on and keep things moving. Framework proof ### We co-authored the new animation backend in React Native 0.85 The new Shared Animation Backend moves core animation update logic into React Native itself. It unlocks performance improvements in Reanimated that were not possible before and lets Animated animate layout props with native driver. Read the release notes Library proof ### Reanimated 4 brings CSS animations and transitions to React Native The animation model developers know from the web is now available natively on iOS and Android, with CSS-style keyframes, transitions, and timing functions running on the UI thread. Read the post ### Reanimated 4 Stable Release — the Future of React Native Animations Client proof ### Partiful – Google Play’s Best App of 2024 Our client had a clear goal: feature parity across iOS and Android without compromising the experience. We recreated Android blur effects, built transparent video playback running directly on the GPU, and added iOS Live Activities with Reanimated, Gesture Handler, and custom native modules. ### How we refined Google Play’s Best App of 2024 One of 26 apps for 2026 by Apple Rating on Google Play 4.9 Read the case study ### Efficient 3D graphics and AI on the GPU Krzysztof Piaskowy’s App.js Conf 2025 talk shows how WebGPU combined with Three.js, Reanimated, and Worklets makes high-performance 3D rendering and on-device GPU computation possible in React Native. ## Contact Email projects@swmansion.com or use https://swmansion.com/contact/ --- # On-Device AI & Local AI Development Software Mansion builds local AI and on-device inference for mobile. We created React Native ExecuTorch and help teams ship private, offline AI features in p... Why local AI ### Latency, privacy, cost, and offline reliability change the product equation Teams pick local AI because it removes the network from the critical path, keeps sensitive data on the device, and changes the economics of features that run all day. ### Latency that cloud APIs cannot match Whisper-tiny encodes 30 seconds of audio in 89ms on-device. A cloud API round trip alone typically takes 200-800ms, before processing starts. ### No data leaves the device Audio, text, and video are processed locally, which matters for healthcare, legal, finance, and products handling regulated or confidential data. ### Works offline Field tools, low-connectivity markets, and mobile-first apps can keep AI features working anywhere users are, with no internet required. ### No inference costs at scale Cloud inference fees scale with usage, while on-device models run on hardware the user already owns. ### Independent of third-party uptime An API outage does not have to take your product feature down with it. What we build ### From model selection to a working local AI feature in your app We handle the full stack: picking the right model, integrating it with your codebase, and tuning performance on real devices. ### On-device inference pipelines We integrate quantized and distilled models into mobile apps using ExecuTorch, Core ML, and XNNPACK. We have shipped LLaMA 3.2, Qwen, Whisper, Kokoro, custom vision architectures, and adapt to whatever model your product requires. ### React Native ExecuTorch integration We built and maintain react-native-executorch, an open-source library that brings PyTorch Edge runtime to React Native with typed hooks for language models, speech recognition, text-to-speech, OCR, and image segmentation. ### Quantization, distillation, fine-tuning Smaller, faster models require compression work. We apply quantization, weight distillation, and task-specific fine-tuning to hit your latency and accuracy targets. ### On-device RAG We build retrieval-augmented generation that runs on the device: local embeddings, local vector search, and local generation using our react-native-rag library. ### Private LLM apps We build fully offline LLM chat interfaces using the same approach as our open-source Private Mind demo. ### Agentic workflows on the edge We build agent pipelines using LangChain and LangGraph, with local model execution and selective remote fallback where needed. Why Software Mansion ### On-device AI in React Native is close to our daily work Most teams integrating on-device AI are working with tools someone else built. We wrote react-native-executorch from scratch, benchmark on real hardware, and maintain the libraries that a significant part of the React Native ecosystem depends on. ### Authors of react-native-executorch We built and open-sourced the library that brings Meta's production PyTorch Edge runtime to React Native: a direct path to on-device LLM, ASR, TTS, and computer vision without writing native code. ### Creators of react-native-rag We created an on-device RAG library for local embeddings, vector search, and LLM augmentation with no cloud dependency. ### 2.5M+ weekly npm downloads Our libraries, including Reanimated, Gesture Handler, and Screens, run in production apps used by hundreds of millions of users. ### Open source is part of our job About 30% of our engineering goes into open source. Our on-device AI libraries are maintained by the same engineers who build with them commercially. From our engineers ### Read how on-device AI changes the cost and latency tradeoffs Our engineers write about the production tradeoffs behind edge AI, including where on-device execution wins and what it cannot do yet. Read the blog post ### On-Device AI Beats Cloud for TTS – Here’s Why How we can work with you ### Some teams come with a prototype to improve. Others come before any model has been selected. We work across all stages, from technical review to production implementation and hands-on pairing with your engineering team. ### Technical audit We review your AI architecture, model selection, runtime configuration, and latency profile. You get a prioritized set of changes with the most impact on performance and cost. ### Full implementation We design and build the on-device AI pipeline end to end, including model selection, optimization, runtime integration, and a working feature in your codebase. ### Expert pairing We work alongside your engineering team, bringing our tooling, benchmarks, and knowledge of how ExecuTorch and mobile runtimes behave in production. Conference talk ### Running Small Language Models on Your Phone Mateusz Kopcinski spoke at App.js Conf 2025 about why privacy, latency, and offline support change the calculus for mobile teams. Let's connect ### You do not need a fully defined local AI project to reach out Share your current stack and what you want to make possible. We will tell you what is realistic for private, offline AI in your product. Talk to our team ## Contact Email projects@swmansion.com or use https://swmansion.com/contact/ --- # React Native Upgrades, Migrations & Modernization We help you upgrade and modernize your React Native app without disrupting your development workflow. Explore the areas where we can support you. ### We know about breaking changes before they ship We are a founding member of the React Foundation. When the direction of the framework is discussed, we are in that conversation. ### 10+ years contributing to React Native core and infrastructure ### First library compatible with Fabric React Native Screens was the first component library in the ecosystem compatible with Fabric ### React Native 0.85 shipped with a Shared Animation Backend we built with the core team. ### React Foundation founding member We help shape the future of the framework alongside Meta, Vercel, and Expo. How we can help ### React Native upgrades and migration services for your app If you are stuck on a React Native upgrade, we can tell you what is wrong and fix it for you. ### React Native version upgrades Older React Native versions accumulate incompatibilities that compound with every passing release. We handle the full upgrade path, from migration planning through to a working app. ### Expo SDK upgrades We are the top contributing group in the Expo ecosystem. We can help with config plugins, EAS compatibility, native module bindings, and the details that block SDK updates. ### Legacy React Native app modernization Older React Native apps often rely on deprecated APIs, outdated navigation patterns, and code that was not built with today's architecture in mind. We can bring them up to date without a full rewrite. ### React Native New Architecture migration The Old Architecture bridge is gone. We have been building for Hermes V1, Fabric, and TurboModules since before most teams knew they were coming. ### Dependency and library upgrades Third-party library updates are where most upgrades quietly fall apart. We audit, resolve, and test the full dependency tree so package conflicts and native SDK mismatches do not block your release. ### Ongoing React Native maintenance Keeping up with React Native is usually easier than catching up. We provide ongoing maintenance and regular upgrades so your team does not have to handle accumulated changes all at once. ### React Native upgrade consulting Not sure where to start? We assess your current setup, map risks and opportunities, and give you clear recommendations before expensive decisions turn into technical debt. ### AI-assisted upgrades We use AI to speed up migrations across large codebases and validate changes more efficiently, using our own tools, skills, and workflows to deliver upgrades at scale without compromising quality. Client proof ### See what our clients say: Being so well connected in the React Native community and supporting key open source projects, we know Software Mansion is always up on the latest developments. Framework proof ### Helping shape Hermes V1 When React Native introduced Hermes V1, we collaborated with Meta to make it available to the community as an opt-in feature. Read the Hermes story ### Welcoming the Next Generation of Hermes Library proof ### Porting key React Native libraries to HarmonyOS NEXT We helped bring Reanimated, Gesture Handler, Screens, WebView, SVG, and Safe Area Context to HarmonyOS NEXT, giving us firsthand experience with compatibility issues that come with major migrations. Read the HarmonyOS story ### Huawei x Software Mansion: Bringing React Native Support to HarmonyOS NEXT FAQ A few practical details about how React Native upgrade engagements usually work. ### Frequently Asked Questions Will the upgrade affect my current release cycle? Not at all. We structure the work so your regular releases keep running on schedule. The upgrade happens in a way that is isolated from your production pipeline until you are ready to ship. Our app uses a lot of third-party libraries. Can you handle those? Yes. Auditing and updating third-party native modules is usually the trickiest part of any React Native upgrade, but we have upgraded dozens of community libraries for our own open-source work and for client codebases. Do we need to be on a specific React Native version to work with you? No. We work with teams wherever they are in the upgrade path, whether they are still on an older version, mid-migration to the latest one, or troubleshooting issues after a recent bump. How long does a typical engagement take? It depends on scope. It can be a few days to bump and test a small app, weeks for larger projects and months for complex apps with custom solutions and enterprise needs. If you want to discuss details, just fill out the contact form, and let’s talk about your project. Then, we’ll be able to give you a more specific answer. ## Contact Email projects@swmansion.com or use https://swmansion.com/contact/ --- # Consulting & Advisory Get our senior engineers to review your architecture, solve complex production problems, improve app performance, or guide your technology decisions. ### We know the ins and outs of the technologies we advise on of building custom software engineers, designers, and QA specialists on board of production issues investigated across mobile, backend, and infrastructure coffees drunk solving those production issues Our engineers contribute to React Native and Expo, and maintain open-source libraries used by production apps around the world. We've spent years debugging mobile, backend, and infrastructure problems – both in client projects and inside the frameworks themselves. That means when we look at your product, we're often able to see problems that are difficult to spot from the application level alone. Need advice before building something new, or help diagnosing an issue that's slowing your team down? We'll find the actual cause. How can we help ### Planning ahead or dealing with a tech problem? We can help ### Architecture review The earlier you validate your architecture, the cheaper it is to change. We'll review your system design, technology choices, feature approach, or migration plan, point out trade-offs, and help you avoid decisions that would become expensive to reverse later. ### Migrations and upgrades Major upgrades can introduce compatibility issues, performance regressions, or unexpected changes in app behavior. Not sure if your product is ready for it? We can help you plan your migration, identify potential blockers, and reduce the risks. ### The right technical approach We know some problems have multiple valid solutions and sometimes it's hard to choose the best one. We can help you compare implementation options, understand the trade-offs, and choose an approach that's appropriate for your product. ### Performance issues Slow startup, excessive battery usage, rendering bottlenecks, or large bundle size – we'll profile your application on real devices, identify what has a negative impact on performance, and recommend specific changes. ### Production-only bugs It's frustrating when some issues only appear in production, on specific devices, OS versions, or network conditions. We can help you investigate telemetry, crash reports, and runtime behavior to identify problems that can't be reproduced locally. ### Android-specific issues Many of our clients prioritize the iOS version during the early stages of development or encounter Android-specific technical challenges. If that's the case for you, we'll resolve the underlying issues and bring your Android app up to the same standard as iOS. ### CI/CD & build pipeline issues We know unreliable CI slows releases. If you're experiencing issues with GitHub Actions workflows, EAS builds, or deployment automation, we'll identify the weak points and improve your pipelines. ### Missing native functionality When a feature or component isn't available in the ecosystem, we can build it for you. We develop custom native modules and platform integrations for iOS, Android, or cross-platform apps – the same way we built and continue to maintain Reanimated and Gesture Handler, which are now used by millions of apps. Why you should trust us ### At Software Mansion, we value proof over promises The effort to make it fast on both platforms was beyond our skillset. The team at Software Mansion jumped in, onboarded very quickly, and made an impact right away. ### Delivering Precise Playback & Cutting Audio Preloading by 85% in a Content Aggregator App ### Delivering Precise Playback & Cutting Audio Preloading by 85% in a Content Aggregator App When we started working with Perch, their audio took 10 seconds to start playing, which is way too long for a podcast app. We reviewed the architecture, rebuilt the streaming pipeline, and reduced load time to just 1.5 seconds. Read case study ### Optimizing Battery Usage & Improving Crash-Free Rate for the Boating Community ### Optimizing Battery Usage & Improving Crash-Free Rate for the Boating Community While the iOS app worked pretty well, SeaPeople faced an Android-only bug that trapped users in a constant restart loop. After careful profiling, we fixed the root cause, boosting their crash-free rate from 95% to 99% in just three months. Read case study ### Modernizing Photobucket's React Native App – and the Team Behind It ### Modernizing Photobucket's React Native App – and the Team Behind It We worked with Photobucket as an embedded partner. Beyond delivery, we helped the team level up through code reviews, knowledge sharing, and React Native coaching. Read case study ### Let's improve your app together You don't need to have a fully diagnosed problem to reach out – just tell us what seems to be wrong or share a plan you'd like to discuss with us. FAQ ### Frequently asked questions My app is laggy on Android but fine on iOS. Can you help? Yes, this is one of the common situations we work with. We can help you bring your React Native Android app in line with your iOS app in terms of quality, performance, and user experience. Can you just review our idea or architecture, or do we need a full engagement? Yes. We often help teams think through technical decisions before they commit to a bigger project. Sometimes it's a single consultation call; sometimes it turns into a longer project. You can start from a single consultation and decide what makes sense from there. We have a production bug we can't reproduce locally. Can you help? Yes. Just share what you're seeing in your analytical tools, crash logs, device details, and anything else you know. We'll do our best to help trace the root cause and figure out what's actually happening. Our CI/CD or EAS setup has become unreliable. Can you help us fix it? Absolutely. CI pipelines often become messy as apps grow and dependencies change. We'll look at what's failing, clean up the setup, and make your pipeline more reliable. What technologies do you work with? We work with React, React Native, Elixir, Phoenix, JavaScript, native mobile technologies including Kotlin and Swift, and many more. We also work with the surrounding tools and platforms needed to build production apps. Can't AI coding assistants solve these problems now? AI tools are getting better and better at digging into complex problems, but it often helps to have someone experienced with debugging or profiling at the helm. This way you avoid getting stuck on the wrong path while the problem stays in production and the customer satisfaction plummets. ## Contact Email projects@swmansion.com or use https://swmansion.com/contact/ --- # Real-Time Video & Motion We build low-latency real-time video, live streaming, and smooth React Native animations – from WebRTC architecture to Reanimated and Gesture Handler. ### We've spent years solving problems most teams don't encounter Building animations and video features Engineers, designers, and QA specialists on board We maintain React Native's key animation libraries like Gesture Handler or Reanimated We organize our conference for audio and video devs Building smooth animations and reliable real-time video takes more than choosing the right tools. Over the years, we've helped clients build multimedia products while also contributing to the technologies behind them. Working on both sides has taught us where the tech tends to break, when animations stop feeling natural, and what it takes to keep video reliable. Thanks to it, we know how to make interactions feel natural, keep video reliable under load, and build multimedia features that grow with the product. How can we help ### Bring real-time video and motion to your product If you want to add low-latency real-time video or smooth user interactions and animations to your product, we can help you create experiences that will set it apart. ### Real-time video features We help you build interactive video experiences; from video calling and real-time collaboration to media processing. We'll choose the right architecture, optimize it for low latency, and ensure the solution performs reliably in production. ### Live streaming & broadcasting Whether you're streaming to hundreds or millions of viewers, we can help you design a delivery pipeline that balances latency, video quality, infrastructure costs, and scalability, so your broadcasts stay smooth as your audience grows. ### WebRTC video calling & conferencing We know how to build low-latency video calling and conferencing that stays responsive across devices and changing network conditions. We'll help you design the right WebRTC architecture and deliver a seamless communication experience. ### Video infrastructure optimization Want to improve the performance, reliability, and cost of your video platform? We'll identify bottlenecks, optimize your infrastructure, and help your system scale more efficiently. ### Media processing & video pipelines If your multimedia product needs to combine, process, or transform video before it reaches users, we can help you choose the right architecture. We'll also build efficient media pipelines that can scale as your product grows. ### Smooth interactions Motion should make your product easier to use, not just look better. We'll help you design animations and interactions that guide users, provide clear feedback, and improve UX. ### Mobile animations & gestures Today's users notice every dropped frame, even if they can't explain why something feels off. We build animations, gestures, and transitions that stay smooth and responsive across iOS, Android, OpenHarmony, or the web. ### Cross-platform experiences Some interactions are harder to get right than they seem. We'll help you build experiences that behave consistently across iOS and Android while respecting each platform's conventions. ### Advanced rendering & visual effects If you're building custom rendering, transparent video, visual effects, or other multimedia experiences, we'll help you choose the right architecture and bring the idea to life. ### Animation performance Animations tend to get harder to maintain as apps grow. If you're dealing with sluggish performance, we'll help you find the rendering bottlenecks, cut dropped frames, and ensure interactions feel smooth. ### Here are some of the projects we've completed ### Cutting Live Broadcast Latency From 7 to 2 Seconds for a Group Chat App ### ChatBCC We used our Fishjam multimedia hub to help ChatBCC cut live broadcast latency from about 7 seconds down to 2, while lowering their broadcast costs by roughly 40%. Read case study ### Reanimated & Gesture Handler We're the creators and maintainers of React Native Reanimated and Gesture Handler – two open-source libraries that power most React Native apps out there. Each of them has over 5M weekly downloads on NPM. ### Refining an Event Planning App That Won Google Play’s Best App Award ### Partiful We brought transparent video and blur effects to Partiful's React Native Android app, and built Live Activities and an App Clip for iOS – creating a truly native experience on both platforms. The app went on to win Google Play's Best App of 2024. Read case study ### Bringing Real-Time Audio to a Public Benefit Corporation Messaging Platform with Elixir WebRTC ### Turn.io We helped Turn.io add real-time voice calls, live transcription, and an AI assistant to its Elixir messaging platform, making it easier for health workers to support underserved communities. Read case study ### Let's move your project forward Tell us what you're building, and we'll help you create reliable multimedia experiences – from smooth animations to real-time video. FAQ ### Frequently asked questions How quickly can you build a proof of concept for a real-time video feature? It depends on the complexity, but most proofs of concept take a few weeks. For example, we built and benchmarked three different architectures for a ChatBCC's live-streaming feature in just two weeks. Can you improve an existing video or WebRTC implementation? Yes. In fact, optimizing and fixing existing systems is a big part of what we do. We'll review your current setup, identify the bottlenecks, and recommend whether it needs optimization, a redesign, or a different approach altogether. Do you only work with React Native? No. While we specialize in React Native, we also work with native iOS (Swift), Android (Kotlin), and the web when the project calls for it. What do you need from us before you can scope the work? Just enough context to understand your product, your goals, and the challenges you're facing. You don't need to know the technical solution – we'll help figure that out together. Do you offer fixed-price projects? We can provide a fixed-price estimate after an initial discovery phase. That said, we usually recommend a time and materials engagement, as multimedia and real-time video projects often evolve during development and are difficult to scope upfront. ## Contact Email projects@swmansion.com or use https://swmansion.com/contact/ --- # Team Augmentation Want to embed your team with senior engineers? We can extend your team with React Native, web, and AI specialists who make an impact right away. ### Work with engineers behind the tools you use of shipping production software engineers, designers, and QA on the team of engineering time dedicated to open source, giving us deep expertise Our engineers are core contributors to React Native, Expo, and Elixir, and we're founding members of React Foundation, alongside companies like Meta, Amazon, and Microsoft. But we aren't tied to these stacks – we work with diverse technologies across mobile, web, and backend systems, helping teams increase engineering capacity. We are trusted by the biggest engineering teams like Chime, Amazon Developer, Huawei, or Klarna. How can we help ### Choose a staff augmentation model depending on what you need ### Why should you work with us? ### Refining an Event Planning App That Won Google Play’s Best App Award ### Partiful We joined Partiful's engineering team to bring iOS-native features like transparent video and Live Activity to Android. The app later won Google Play's Best App of 2024. Read case study Software Mansion brought exactly the technical depth we were looking for. They helped us modernize our React Native app and leveled up our team in the process — by the time the engagement wrapped, we owned the work and the know-how behind it. A genuine partner, not just a vendor. ### Modernizing Real-Time Infrastructure and Improving Observability for Supabase ### Supabase Our engineers joined Supabase's Observability and Realtime teams to migrate their SDK to canonical Phoenix.js and modernize their logging pipeline, all without disrupting existing users. Read case study Can you believe you can hire these guys? The Software Mansion guys? The guys with their logo on every package? It feels too good to be true, but it’s true. ### Ready to extend your team? Tell us about your project and needs, and we'll get back to you with next steps and how we can support your team. FAQ ### Frequently asked questions How do you choose engineers for projects? We know our engineers, their strengths, interests, and experience very well. And we take time to find the right fit for each client. So, instead of sending you multiple random profiles, we get to know your team and product so we can recommend engineers who will work well with you from the start. How fast can your engineers start? In some cases, we've started projects within 2 days. There are always some formalities to handle, but our open-source work means we have experienced engineers who can quickly step in when your project needs specific skills. Do your engineers work in our process and tools? Yes. Our engineers join your repositories, workflows, and communication channels and work as part of your team. We adapt to the tools you already use – whether that's GitHub, Slack, or other tools in your workflow. Is there a minimum team size to start? No. You can start with a single engineer and scale as needed, but most teams get the best results when working with a focused group. Can I scale the team up or down as my needs change? Working with us, you can scale your engineering team up or down as needed without disrupting delivery. We have 400+ specialists across React Native, web, Elixir, real-time systems, and AI, so you can be sure we can quickly bring in the right people for your project, without hiring delays or long-term overhead. Can you just help us meet a specific deadline? Yes, when deadlines are tight or your team is at capacity, we can take over part of the delivery or the whole project. We'll need some time to understand your product and codebase, but we can quickly help you move the project forward. And if we don't believe the deadline is realistic, we'll tell you upfront. Do you only do React Native? No. React Native is where we're best known, largely because of our open source work and the tools we've built around the ecosystem. But we also have strong teams working across full stack, backend, web, real-time systems, and AI. We always match engineers to projects based on the problem you need to solve. How do you prepare the codebase for when our collaboration ends? We understand that products naturally grow and clients often build their own teams over time, which is why we want them to fully own the technology behind their products. We provide clear documentation, share good practices, and collaborate closely with your team so your engineers can continue independently. We also involve your technical team in important decisions throughout the project. Where are your engineers based, and do time zones work? Our team is based in Kraków, Poland, with overlap across European hours and US mornings. We know how to adapt to your team's workflow and communication style so collaboration stays smooth. ## Contact Email projects@swmansion.com or use https://swmansion.com/contact/ --- # Software Development We build and scale custom software from idea to launch: mobile, web, backend, and on-device AI. 13+ years on the market, 400+ specialists on board. ### We know what building products actually feels like of building custom software engineers, designers, and QA specialists on board end-to-end development projects completed pivots done during these projects The best product teams don't try to get everything right the first time. They prototype quickly, learn from customer feedback, and make decisions based on what they discover. That's how we like to work, too. We build cross-functional teams that give you room to experiment, pivot, and scale without unnecessary processes or long-term commitments. And while we're best known for React Native and many of our projects are mobile apps built with it, we always adapt the team and technology to what your product needs, from React, Next.js, and PostgreSQL to newer tools like Convex or Astro when they make sense. How can we help ### Software development services tailored to your needs and scope Client proof ### Why should you build software with us? ### Refining an Event Planning App That Won Google Play’s Best App Award ### Partiful We helped build the Partiful app that won Google Play's Best App of 2024. We brought iOS-grade features such as transparent video, App Clip, or Live Activity to Android, reaching feature parity across platforms. Read case study “The team & Software Mansion engineers are incredibly responsive and adaptive to our process and only strive to make things better. When it comes to communication with the vendor, their Account Managers are responsive, understanding of any issues that arise (if any) and helping to think through the situations while thinking of the best outcome for both our company and their team. I'm impressed with their very high-quality and result-oriented team members. SWM has been a great partner for us!” Can you believe you can hire these guys? The Software Mansion guys? The guys with their logo on every package? It feels too good to be true, but it’s true. ### Developing a Medspa Platform That Contributed to 10x Client Growth ### Moxie We built an all-in-one medspa management platform from scratch. MVP in two months, ~10x client growth in nine, and app-related churn down from 30% to 0% in a year. Read case study ### Let's build your product together Tell us what you're working on and where you need help, and we'll help you figure out the best plan for your product. FAQ ### Frequently asked questions Will you take a project from just an idea? Yes. Many of our projects and conversations start as a one-line idea. That's why we run a short discovery call to get to know your vision and give you a plan with real timelines before you commit to the full build. How fast can we get to an MVP? It depends on the product, but it's usually a matter of weeks. For example, we shipped Moxie's first usable version in two months. If you want to find out the concrete timeline, fill out the contact form and we'll get back to you. What's the smallest project you can take? We work on various projects, from early product validation to building production-ready solutions. The right fit depends less on the size of your project and more on whether we share the same vision and ways of working. What do I need to have before reaching out? You should have a clear vision for the product and someone on your side who can take ownership of the idea and product decisions. But if you're still figuring out how to define the project, we can help you shape it through workshops or discovery sessions. I want to develop for both mobile and web. Can you help me? Yes. We're a full-stack development agency. For example, we've built cross-platform mobile with React Native and Expo, web with React and Next.js, and the backend with Python/Django, Elixir, or Postgres. But we're comfortable with other tech too. We built our first version on a no-code tool. Can you take it from here? We can productionize the validated parts of your project on a stack tailored to your goals, and keep the product logic you've already proven, while cleaning up low-quality code and fixing issues introduced by no-code tools. Why Software Mansion over anyone else? Because we've shipped products that win Best App of the Year, we maintain open source tools the React Native ecosystem runs on, and we've been doing this for 13+ years as a publicly-listed company. With us, you have design, product, and engineering in one team, so everything stays consistent from idea to deployment, and you can be sure we choose the right stack for your product every step of the way. Can you just give me a price for my product? If your project is well-defined, we can estimate the scope and expected investment. However, we usually work with a time-and-materials model because building a product is an iterative process. This gives us the flexibility to test assumptions, make pivots, and continuously improve the product as we move on. ## Contact Email projects@swmansion.com or use https://swmansion.com/contact/ --- # Mobile App Modernization We modernize React Native apps without disrupting your release cycle – performance audits, tech debt reduction, migrations, and major version upgrades. ### We've seen every era of React Native, and we know why things changed of building custom software engineers, designers, and QA specialists on board founding members, alongside Meta, Microsoft, or Expo to the New Architecture Some of our engineers have been working with React Native since its early days. We've seen the ecosystem evolve, so we understand not just *what* changed, but *why* it changed. We know what still works well, what has reached the limits, and how to replace outdated solutions without introducing unnecessary risk. We also know that production software is never built from a blank slate – every app reflects numerous business and technical decisions. That's why we don't recommend rewrites when they aren't needed. Most of the time, we help teams modernize incrementally, keeping what still works and improving what doesn't, while making sure they can ship without disruption throughout the process. How can we help ### Pick the level of help your app needs Learn more Learn more ### See how we've helped teams modernize their products Software Mansion brought exactly the technical depth we were looking for. They helped us modernize our React Native app and leveled up our team in the process — by the time the engagement wrapped, we owned the work and the know-how behind it. A genuine partner, not just a vendor. ### Optimizing Battery Usage & Improving Crash-Free Rate for the Boating Community ### SeaPeople SeaPeople is a social platform for boaters built with React Native. In just over three months, we modernized the app's foundations, improved its crash-free rate to nearly 99%, and introduced new social features that gave the team a solid platform for future development. Read case study ### Modernizing Real-Time Infrastructure and Improving Observability for Supabase ### Supabase We helped Supabase modernize its Realtime.js SDK and Logflare's observability pipeline, migrating a package with nearly 20 million weekly downloads to canonical Phoenix.js without disrupting existing users. Read case study ### Welcoming the Next Generation of Hermes Together with Meta, we worked on Hermes V1 – the next generation of the Hermes engine – and helped bring it to the React Native community as an opt-in feature in React Native 0.82. ### Ready to modernize your app? Tell us about your app, and we'll help you figure out where to start and what modernization work will have the biggest impact on your product. FAQ ### Frequently asked questions Do you only work with React Native? No. React Native is where we're best known, but we also help teams upgrade backend systems, infrastructure, build tooling, and native code across technologies like Elixir, Phoenix, Swift, Kotlin, and more. How is working with you different from hiring a consultant? A modernization project often starts with an audit, and we can help you understand where the biggest risks are. The difference is that we don't stop there – our engineers can join your team and implement necessary changes alongside your developers. Will this disrupt our release cycle? No. Before we make any changes, we take the time to understand your codebase and release process. Then we plan the work around your roadmap, so your team can keep shipping while modernization happens in parallel. Do we need to commit to a long engagement? No. Some teams bring us in for a short audit or a specific migration. Others work with us over months or years. We don't need to decide the length of the engagement upfront – we can recommend the right scope based on your project's needs, but you're free to end the collaboration whenever you feel the time is right. Can we keep parts of our legacy architecture? Of course – if part of your architecture still works well and you don't want to change it right now, we'll keep it. How do you work and where do you start? We start with looking at your codebase. Once we understand how your app is put together, we can identify what's creating the most risk, what's worth improving first, and how to fit that work into your team's existing release cycle. ## Contact Email projects@swmansion.com or use https://swmansion.com/contact/ --- # Software Development for AI If you want to build AI features smartly, you're in the right place. We're AI experts who started working with edge AI before the hype began. ### We know AI from both sides, because we've built products *with it* and built tooling *around it* of shipping production software engineers, including a dedicated AI team of tokens spent testing ideas, workflows, and models our open-source on-device AI library We've been building AI-powered products long before they became mainstream; integrating AI into apps, researching LLMs, and making models run directly on users' devices. Along the way, we learned both what these models are capable of and where their limitations begin. When AI coding tools arrived, of course, we embraced them too. But getting AI to generate code is the easy part; the real challenge is building the workflows, validation, and tooling that actually makes engineering teams more productive. That's exactly why we built tools like Argent – to solve problems we faced ourselves. Today, we help teams get real value from AI-assisted development. **So, whether you need production-ready AI features, better engineering workflows, or custom tools and pipelines, we'll get you there faster.** What we can help you with ### Engineering services for modern AI products Learn more ### Here's some of the AI work we've shipped Private Mind is an AI assistant that runs entirely on your device. It's a real-world demonstration of how we build private, responsive AI experiences powered by local language, speech, and vision models. Check it out ### We were building on-device AI tools before the hype began Before on-device AI became popular, we were already shipping it in real products: we built React Native ExecuTorch, a library for running AI models directly on the device, and Private Mind, an on-device AI assistant. Learn more ### From Zero to 300K Users in One Year: How We Built an App That Builds Apps ### Vibecode We built key parts of the AI-powered app builder for Vibecode, where anyone can create mobile and web apps using natural language. Starting from an early prototype, we turned it into a product featured by Anthropic as a flagship Claude-powered app. Read the case study Being so well connected in the React Native community and supporting key open source projects, we know Software Mansion is always up on the latest developments. ### Introducing React Native RAG: Local & Offline Retrieval-Augmented Generation We brought retrieval-augmented generation (RAG) to the device with React Native RAG, making it possible to ground AI responses in private data without sending that data to the cloud. ### Argent We've created Argent, an agentic toolkit that controls, debugs, and profiles iOS and Android applications. And users love it, stating it's the most impactful dev tool that improved their workflows. Learn more ### Let's talk about agentic development in your product Tell us what you're building, where you think we could help, or what challenges you're running into. We'll help you figure out the right approach. FAQ ### Frequently asked questions Why should I consider on-device AI? Three reasons your users and your budget will feel: privacy (data never leaves the phone), cost (no per-call inference bill or server infrastructure), and speed (no network round-trip). For anything privacy-sensitive or high-volume, on-device often wins outright, but if you aren't sure what's best for your project, just contact us. We built our app with an AI coding tool and it's a mess. Can you fix it? Yes, this is common and fixable. We keep the product you've validated and improve the foundation: clean architecture, tests, CI and monitoring. Thanks to it, you can keep your app growing and get rid of any spaghetti code. Do you only do mobile AI? On-device mobile AI is what we feel best with, but we also build AI features for web products, as well as the cloud and hybrid AI features, AI-assisted developer workflows, and the backends behind them. During a call, we can help you choose the approach that makes the most sense for your product. Can you help our team work faster with AI? Yes. We help engineering teams get real value from AI by sharing the workflows, tools, skills, and practices we've developed while building big products at scale. With 400+ engineers working on various projects across different industries, we've seen a wide range of problems and solutions — and we can help your team apply what actually works in practice. ## Contact Email projects@swmansion.com or use https://swmansion.com/contact/ --- # 300% More Active Users of a Camping App Developed with React Native Campy offers a platform for nomads, motorhome lovers, campervan travelers, and RV adventurers. The client reached out to us with a clear vision: to build Europe’s ultimate camping app, loaded with features to simplify and speed up trip planning. Leveraging our React Native expertise, we dove right in, nearly tripling Campy’s active user base and increasing average engagement time by over a minute. ## Services Performed - Mobile app development - Backend refactoring & development - App performance optimization - Product development & growth - Monitoring 3rd party integrations ## Tech Stack - React Native - Node.js - Google Cloud - RN Reanimated - RN Gesture Handler - RN Screens - RN SVG - RN Firebase - React Navigation - RN Maps ## Goals & challenges Campy started developing the camping app in-house but quickly realized specialized expertise was crucial to scale. That’s where we came in, using our React Native skills to enhance the app’s functionality and usability. Campy’s goals were to: Grow a loyal user baseBuild an extensive database of campsites across EuropeLaunch subscription-only features for revenue growthIncrease engagement with user-generated reviews, photos, and campsite edits From day one of our cooperation, we collaborated closely with Campy’s team to ensure the app's development was on track and lay a strong foundation for the app’s ambitious growth. Integrating APIs to expand the database One of Campy’s main goals was to grow the user base, so we focused on building out its campsite database across Europe. Since the app’s value comes from its content, having a wide and accurate selection of campsites was crucial for attracting new users and keeping them engaged.  To achieve the goal, the client leveraged the Places library in the Maps JavaScript API to gather key information about campsites, including locations, amenities, reviews, and pricing. We then developed a custom "campy-scraper" to pull additional details from campsite websites. By applying LLM processing, we refined and integrated this data into Campy’s database, ensuring it was comprehensive and up-to-date, giving users reliable information for planning their camping adventures. Over the first year of our partnership, the number of app users increased by 67%. Increasing the number of subscriptions To help Campy grow revenue – increasing not only the number of free users but also of paid subscriptions – we teamed up with its crew to roll out premium features such as: Camper navigation – we integrated Mapbox’s API, letting users input their vehicle’s dimensions to get custom routes that avoid unsuitable and unsafe roads.Multiple favorite lists – premium users gained unlimited favorite lists, giving them more ways to organize and personalize their campsite picks.Distance map layers – multiple options to display locations within a set distance or travel time radius.Weather forecast – for every location available in the Campy app, users can view a 7-day weather forecast.Discover trips – gathers the most interesting trips in one place, giving users a curated selection to explore and a great starting point for planning.Unlimited trip copies – enables users to copy trips from Discover to My Trips, where they can modify the stops or change the order to suit their needs. To promote the premium subscription, we collaborated with Campy to enhance app communication and marketing strategies. We implemented in-app notifications, emails, and banners to highlight the benefits of premium features, alongside prompts encouraging users to upgrade immediately after sign-up. We also introduced a referral program, letting existing users share a link for three months of free premium access with friends, making it easier to bring in new sign-ups and spread the word about premium features. On top of that, we ran A/B tests on different pricing models and purchase screens to figure out the best way to boost conversions. The app tweaks, premium features, new additions, and marketing efforts all contributed to a more than fivefold increase in revenue in one year. Seamless trip planning and experience sharing Campy’s vision wasn’t just about functionality – the client wanted to build a lively, engaged community. To make it easier for app users to plan trips, share photos, and tell the stories behind their adventures, we introduced the Trips feature. This feature allows users to: like and comment on each other's tripsbrowse travel suggestions in the Discover tabcopy public trips to modify themcreate their own trips using available campsitesadd descriptions and photos to stopsshare trips with friends follow friends’ trips to get notified about updates. Not only does it provide inspiration, but it also boosts user engagement by making the app a fun and engaging place where users can stay connected and interact with one another. Boosting community engagement with gamification and the Discover section To improve app retention, we built a gamified system where users earn "leaves" for any user-generated content like reviews, photos, or campsite details. When they contribute, the leaves grow into trees, and for the most active users, into entire forests, encouraging more contributions. We also added a Discover section where users could share trip itineraries with the community and check out others' adventures. The most popular trips would appear at the top of the tab, encouraging users to dive into others' experiences. This turned Campy into a real social platform connecting camping enthusiasts. Improving app speed and performance Our adventure with Campy wouldn’t be complete without fine-tuning the app’s core. We zeroed in on the crucial map-loading performance and mapped out the steps to make it faster and smoother. We improved the Map User Experience by fetching locations only when necessary and based on user demand. Additionally, we eliminated redundant re-renders and removed duplicated fetch requests. The result? Faster map loads, delivering a smoother, more seamless experience in only 2 months: Android: 3.36s → 2.45siOS: 1.24s → 0.97s > "“Very professional. Great communication where correct expectations are set, and topics are discussed well before they become an issue. They always put the interest of our company first and talk about the app as if it were their own, showing ownership and responsibility. What’s unique and impressive is the culture among colleagues and their relationship with clients. It’s fun but always professional, which makes you feel secure and comfortable.”" > — Laurens van Mierlo, CEO & Co-Founder at Campy ## Results During our cooperation with Campy, we fine-tuned app performance, minimized downtime, and introduced new features to help boost in-app purchases. Some project highlights include: --- # Boosting Stability and Reducing Technical Debt for a User Research Platform Dscout offers a remote experience research tech platform that simplifies usability tests, product discovery, competitive analysis, and more. The portfolio of companies Dscout collaborates with includes numerous Fortune 1000 companies. The client reached out to us looking for experienced multimedia and Elixir specialists to fine-tune a custom researcher tool for editing video content. As the project scope expanded, we also dedicated a UI designer to support Dscout's design team with time-sensitive tasks. After successfully completing the initial project, Dscout asked us to rewrite its administrative panel from Ruby on Rails to Elixir. By migrating the panel and modernizing key frontend libraries, we helped improve the platform’s scalability and reduced its technical debt. ## Services Performed - Frontend modernization - Web development - Integration with 3rd-party tools - Migration to Elixir - UI design for time-sensitive tasks ## Tech Stack - React - Elixir - FFMPEG - Apollo GraphQL - Ruby on Rails - JavaScript - TypeScript - React Router ## Challenges Developing Dscout's custom video editing toolAddressing issues with legacy Ruby on Rails parts of the platform that no longer met performance demandsTackling technical debt in frontend libraries like React and Apollo GraphQL, which hindered functionality and updatesSupporting Dscout's design team with time-sensitive tasks ## Developing Playlist Editor Dscout wanted to expand the functionality of Playlist Editor – a custom researcher tool for editing and sharing video content – to make it more user-friendly and simplify presenting research findings. One of the first improvements we introduced was the option to insert slides between clips, which significantly helped users organize their presentations. We also improved audio control by implementing EBU R128 loudness normalization standard, enabling platform users to effortlessly adjust volume levels with one-click, without thinking: "What would be the correct volume level for my video?". What’s more, to ensure researchers can easily protect participant privacy, we collaborated with Dscout to design and introduce an interactive feature that allows users to blur faces in survey recordings. Designing new features As the Playlist Editor grew with new features, we brought a UI designer on our side to work closely with developers and Dscout's design team.
 With both development and UI design aligned under one roof, we were able to move quickly on time-sensitive tasks. This lead to contributing a range of new video features such as face blur, text slides or updated settings panel. Having design and engineering working in close sync meant faster iterations, shorter feedback loops, steady development pace and the ability to turn around production-ready designs in short time. ## Rewriting the admin panel
from Ruby on Rails to Elixir After our successful work on the new features of Playlist Editor, Dscout chose to expand our collaboration with a more complex and time-intensive project – migrating the administrative panel from Ruby on Rails to Elixir. We began by diving into the existing Ruby code, simultaneously identifying areas for improvement. One of the first major tasks in rebuilding the panel was to make the platform management more user-friendly, improve user permissions and build a better search engine.  We also worked on rewriting email processing, email previews and CSV exports, improving the original features where possible on-the-fly. ## Frontend modernization As the Dscout platform expanded, it became necessary to modernize the frontend tech stack. To keep up with modern web technologies, we were engaged in updating key frontend libraries and addressing the technical debt associated with them. Upgrading React The React library is at the heart of the Dscout web platform. However, since the version in use was outdated and lacked many modern features, it started causing growing maintainability issues. During the migration, we worked hand in hand with Dscout engineers. We tackled several technical challenges, including infinite loops in certain user interactions scenarios and flickering UI elements. The regressions were caused by slight changes in React internals and required diving deep into complex abstraction layers. Due to the platform’s size, we also encountered hard-to-identify edge cases, mostly due to a heavy reliance on React behaviors. With the support of thousands of automated end-to-end test scenarios, we collaboratively identified and resolved all edge cases and regressions, and then fixed them with an incremental approach. This enabled Dscout to further modernize the platform, improve the tech stack and take advantage of new cutting-edge web features. Modernizing Apollo GraphQL The Dscout platform relies on the GraphQL API, with the Apollo Client library handling the communication layer and caching mechanism on the frontend. Because of the data-intensive nature of the app, it required hundreds of API query configurations, complex cache management, and requests cooperation. Upgrading the Apollo Client library was crucial to fix multiple issues and benefit from new features and mechanisms provided by its latest versions. The migration required a deep understanding of Apollo internal changes and modernization of Dscout's own data fetching layers. To ensure a seamless transition, we carried out extensive manual and automated testing. Modernizing React Router React Router is the core library used for navigation within the Dscout platform, connecting every part of the app. Modernizing this library was essential to support the latest web navigation features. Since React Router is used on every page and in hundreds of components, the biggest challenge was the scale of the update – it couldn’t be done incrementally. The major changes in the API forced us to completely rebuild the application's routing layers, including multiple nested paths and component compositions. To ensure the app remained stable after migration, we carefully tested and monitored all functionalities. Rebuilding translation mode To make multilingual research more accessible for Dscout's team members, we helped redesign the translation mode. Previously, managing the translations of research questions required switching to a separate tab. What’s more, edits to questions would delete existing translations, which was both inefficient and error-prone.  To solve this, we integrated translation mode into the question builder, adding language tabs and status indicators to show current, missing, or outdated translations. This allows users to update translations immediately after editing questions.  We also helped introduce backend improvements to ensure translations stay in sync with questions. When a question changes, translations are automatically flagged as outdated, and users are asked to revise specific sections. What’s more, validation checks prevent launching missions with incomplete or outdated translations. The improved translation mode allows Dscout to easily toggle between languages, displaying the original text alongside translations for reference. Building an audit log To improve Dscout’s observability, we rebuilt its audit log, transforming it into a friendly and reliable tool for tracking user actions and system events. The original audit log used advanced terminology that was hard to comprehend for non-technical users. To address this, we added a mapping layer that automatically translates system events into clear, actionable descriptions, while preserving technical accuracy for future updates.  The improved audit log ensures regulatory compliance and tracks sensitive events while also offering valuable insights for diagnostics and troubleshooting. ## Supporting Dscout's growth We’ve continued our partnership with Dscout, working together to expand the platform with new features, such as: Bulk updates of consumable balances – Dscout's business intelligence team needed a straightforward way to upload consumable balances, such as activity credits and available support hours, directly into the platform. Thus, we developed a custom solution that allows for seamless CSV uploads via LiveViews. This not only makes bulk updates easier, but also improves data accuracy and overall efficiency in managing consumables.New roles and flexible seats – we supported Dscout in enhancing the role management system, giving clients more flexibility as their needs evolve. Previously, roles had fixed limits and payment tiers, which didn’t allow for much customization or growth. We worked with the client to redefine roles like researchers, admins, and contributors, making them more adaptable. We also migrated the existing framework to support this role-based system, ensuring a smooth transition. Now, clients can scale roles as their teams grow. If an account reaches role limits, Dscout notifies them and offers flexible licensing options, simplifying expansion and creating upselling opportunities. Consumables management system – we helped develop a system to manage consumables, which are incentives deducted from clients to support research respondents. By automating the complex conditions behind consumables allocation, the solution ensures reliable distribution of incentives and can easily adapt to changes in business logic.Optimized license management – managing Dscout clients’ subscriptions previously required frequent API requests through both their own and third-party paid APIs. With a high volume of licenses and API requests occurring every few minutes, the associated costs were quickly adding up. To address this, we worked with Dscout to create a more efficient solution. By implementing batch processing for licenses, we built a solution that enables handling multiple requests at once, significantly reducing the number of individual API calls. This quick win led to noticeable cost savings, allowing Dscout to manage licenses more efficiently. > "“The team & Software Mansion engineers are incredibly responsive and adaptive to our process and only strive to make things better. When it comes to communication with the vendor, their Account Managers are responsive, understanding of any issues that arise (if any) and helping to think through the situations while thinking of the best outcome for both our company and their team. I'm impressed with their very high-quality and result-oriented team members. SWM has been a great partner for us!”" > — Sasha Korobko, Director of Engineering at Dscout ## Results We've been partnering with Dscout since 2021, ensuring developed solutions provide a strong foundation for future growth and meet user needs. By successfully migrating the admin panel to Elixir and modernizing key frontend libraries, we helped boost the platform’s scalability and stability, while reducing technical debt.  To simplify researchers’ workflows, we expanded Playlist Editor and integrated 3rd-party tools to make data analysis more efficient. Additionally, we improved platform observability with a new audit log, providing Dscout teams with deeper insights on user actions and system events. As Dscout's product scope grew, we also supported their design team in adapting to expanded responsibilities – dedicating a UI designer on our side to ensure timely delivery of design tasks under tight deadlines. --- # Bringing Real-Time Audio to a Public Benefit Corporation Messaging Platform with Elixir WebRTC Turn.io is a Public Benefit Corporation and the first impact WhatsApp service. It helps organizations and governments connect underserved communities with health workers, NGOs, and ministries. After discovering Elixir WebRTC during Elixir Stream Week, the client reached out to us for help. At that time, their platform, writtten in the Phoenix framework, LiveView, and React, was already capable of handling large-scale, 
text-based communication. What they needed was a reliable way to support real-time voice calls within the existing infrastructure. During our collaboration, we expanded the platform to support browser-to-Turn.io-to-WhatsApp voice calls, added live transcriptions, and built an AI assistant. ## Services Performed - Integration with WhatsApp WebRTC API - Routing audio traffic between WA and web browser via Turn.io - Voice transcription & AI assistant integration - WebRTC calls debugging & observability ## Tech Stack - Phoenix Framework - LiveView - Elixir WebRTC - LiveDebugger - OpenAI - Kubernetes - Google Cloud Platform - Amazon Web Services ## Goals & challenges Our goal was to bring real-time audio to Turn.io’s browser-based platform, enabling agents to seamlessly connect with people using WhatsApp on their phones. The project involved: Integration with WhatsApp WebRTC API and relaying audio traffic 
between WhatsApp and web browsers (via Turn.io)Adding live transcriptionImplementing an AI assistant and the possibility to switch between 
AI and human operatorsExtending Elixir WebRTC to support receiving DTMF 
(Dual-Tone Multi-Frequency) tones over WebRTCEnsuring connectivity for users across all types of networksCapturing statistics and debug information for future analysis Building audio calling with WebRTC Turn.io’s platform consists of both a web-based frontend (where agents and consultants view and respond to messages) and a backend server that handles message routing by receiving messages from WhatsApp, delivering them to the browser, and sending replies back to WhatsApp. When we joined the project, Turn.io had already been operating for several years, with the whole code and infrastructure for high-volume text messaging already in place. Our role was to extend this foundation by establishing WebRTC connections for real-time audio. This involved connecting WhatsApp to the server and the server to the browser, enabling audio to flow smoothly in both directions. For this purpose, we used Elixir WebRTC – a batteries-included WebRTC implementation for the Elixir ecosystem. It follows the W3C WebRTC specification, providing the same API as web browsers but expressed in an idiomatic Elixir style. Every peer connection runs in its own Elixir process, and every call can include up to four peer connections to: WhatsAppthe web browserOpenAI for the WhatsApp transcriptOpenAI for the browser transcript These connections are managed by another Elixir process called CallRouter, responsible for routing audio packets between them. Improving reliability & debugging To ensure that Turn.io’s voice calling feature works reliably across a wide range of network conditions, we focused on both improving the WebRTC connection establishment process and improving visibility into call performance. As part of this, we implemented a statistics collection using get_stats(), with data stored in the database via the Erlang External Term Format. Based on the W3C WebRTC specification, these post-call metrics, among others, include: bytes and packets sent/receivedretransmissionsNACKsICE connectivity data – including local and remote candidates and the ICE candidate pair gridSDP offer/answer details Thanks to it, when the client team observes unusual behavior, they can easily download a diagnostic file and share it with the Turn.io developers, speeding up the debugging process. Since everything was deployed in Kubernetes on GCP and AWS, we also employed Cloudflare’s TURN servers for the most restrictive network providers (e.g., Orange or WindTre, which use Symmetric NAT). For alternative deployments on bare machines (e.g., Hetzner without K8s), this additional step typically isn't required, provided UDP traffic isn’t restricted for client connections. As part of our reliability work, we encountered a specific issue with Orange ISP: the DTLS (Datagram Transport Layer Security) certificate was exceeding the network’s MTU (Maximum Transmission Unit) and was being dropped en route. Since DTLS is essential to WebRTC encryption and negotiation, this caused the peer connection to fail. To resolve it, we improved our DTLS-SRTP implementation by supporting certificate fragmentation and setting the MTU to 1200 bytes, following WebRTC recommendations. This change ensures large certificates are delivered reliably, even in constrained network conditions. Last but not least, the Turn.io team started using LiveDebugger to make debugging smoother and more efficient. LiveDebugger is our open-source browser-based tool for inspecting and debugging applications built with Phoenix LiveView. It gives the client’s developers a clear, real-time view into the internal state of the platform, helping them spot and resolve issues faster. ## Helping implement AI features Once audio calling was up and running, the next phase of the project focused on enriching Turn.io’s platform with AI-based features. Enabling real-time transcription The first step in bringing artificial intelligence to Turn.io platform was adding live transcription. To improve note-taking and create a clear interaction history, we integrated Turn.io’s audio pipeline with OpenAI to transcribe user-agent conversations in real time, enabling consultants to see a live text version of calls in the browser. A key part of this process was establishing a dedicated WebRTC connection between Turn.io and OpenAI, where Turn.io streams audio via RTP packets, and OpenAI returns transcripts in real time over data channels. Since Turn.io uses ElixirWebRTC, while OpenAI relies on Pion – a WebRTC implementation in Go – the integration came with a few challenges. Although both libraries follow the same standard, subtle differences meant they didn’t interoperate well out of the box.  The main problem was ICE’s aggressive nomination. Pion requires a pair to be nominated by the controlling side before it can start sending any data. Because Elixir WebRTC uses regular nomination, the nomination process happens once all connectivity checks pass, which may take several seconds, delaying the whole flow of data.   To fix that, we added support for aggressive nomination on the controlling side in Elixir WebRTC and made it configurable, speeding up connection establishment time to a minimum. Developing an AI assistant To boost efficiency and help more Turn.io users, the next step was enabling conversations with an AI assistant. Instead of going straight to a human agent, callers can first speak with a bot that understands questions, provides basic answers, or even triggers specified backend actions using OpenAI’s function calling.  The implementation was very similar to live transcription, using OpenAI’s WebRTC API. The main challenge was enabling a smooth handover between AI and human operators. From the WhatsApp user’s perspective, this transition needs to happen seamlessly, without restarting the connection or introducing unnecessary delays. To achieve that, we had to ensure that the RTP packet sequence numbers and timestamps sent to WhatsApp remained continuous, even after the switch. Fortunately, Elixir WebRTC includes RTP Munger, a tool specifically designed for this kind of stream manipulation. This smooth handover was essential to ensure that callers aren’t left stuck with the bot when real human help is needed. We also supported Turn.io in implementing pre-recorded messages, which are especially useful for sharing important general information with callers before they're connected to a human agent or AI assistant. A helpful reference for this feature is our send_from_file example. Working on DTMF support Since OpenAI often struggles to understand spoken numbers, we helped Turn.io use DTMF (Dual-Tone Multi-Frequency) to improve the platform's reliability in situations when users need to share IDs or reference codes during calls with AI assistants. The key part of this feature was implementing DTMF tone reception directly in Elixir WebRTC and exposing it through the API for use in business logic. As a result, callers can press digits on their phone keypad during a call, and these inputs are sent as events via RTP packets, reducing integration complexity and friction on the Turn.io side. This gives users a reliable and familiar way to enter numbers, making the experience smoother and reducing frustration when precision matters. ## Results We’re really happy to have helped Turn.io make the real-time voice chats over WhatsApp smooth and reliable. The audio calling feature is currently used by several of Turn.io’s partner organizations.In the first weeks after the introduction of audio calls, weekly volume grew by over 250% – from around 20 to more than 70 calls.Support for TURN servers and DTMF tones improved platform accessibility and reliability across varied network conditions.The implemented post-call statistics storage helps the Turn.io team troubleshoot issues faster and gain deeper insights into platform performance. --- # Delivering Precise Playback & Cutting Audio Preloading by 85% in a Content Aggregator App Perch is a blog and newsletter aggregator that helps users declutter their inbox, stay up-to-date and discover interesting content, all in one place. The client reached out to us because, while the app performed well on the reading side, they wanted to amplify the experience with reliable audio and accurate sync with UI. The goal was clear: enable natural text-to-speech so any article could be listened to like a podcast – smoothly, without unnatural pauses, and without compromising app performance. Achieving that, however, proved more challenging than simply pressing play. Through our joint efforts, we cut audio preloading from ~10 seconds to ~1.5 seconds and ensured smooth multi-sound and background playback as well as perfectly synchronized audio highlights and progress tracking. ## Services Performed - Mobile app development - Custom audio infrastructure - Performance optimization - Cross-platform integration ## Tech Stack - React Native - RN Audio API - Expo - ElevenLabs - WebSockets ## Challenges & goals When Perch approached us, their existing audio stack – built using React Native Track Player – was causing several challenges. To ensure the app runs smoothly, we needed to focus on: Cutting audio preloading for a smooth user experienceStreaming long articles efficiently to avoid bloated memory and bandwidth usageKeeping playback reliable during actions like seeking, skipping, or resuming after a dropSupporting multi-sound playback, background playback, lock screen controls, and interruption handlingMaintaining natural, ultra-low latency text-to-speech Delivering smooth playback, even for long articles difficult to synchronize with UI Tuning the user experience We started our cooperation with a goal to rebuild Perch’s audio stack from the ground up. The original solution, built using React Native Track Player, suffered from long preloading times and limited scalability. To address this, we moved away from generating full audio files and started streaming articles in real time. Using WebSockets with ElevenLabs’ text-to-speech model, we were able to break articles into smaller chunks, cutting preloading from ~10 seconds to 1.5 seconds. Thanks to react-native-audio-api we could play chunk by chunk in perfect sync with each other, enabling articles of any length to scale efficiently without loading unnecessary data. Furthermore, to make the listening experience feel natural and reliable, we focused on two critical aspects: playback speed and connectivity. First, we optimized playback speed with a TDHS (Time Domain Harmonic Scaling) algorithm, ensuring AI voices “reading” the articles sound natural even when sped up or slowed down. We also ensured support for multiple simultaneous streams so users can preview AI voice samples without interrupting ongoing playback.  Second, we made the player resilient to connectivity issues by building the architecture around a finite state machine. The system has two main services: the AudioPlayer, responsible for playback, and the AudioStreamingManager, handling the WebSocket connection. Thanks to this design, failed audio requests are automatically retried, ensuring buffered audio continues uninterrupted even if the internet drops. This architecture not only makes playback robust, but also enables precise synchronization between audio and the UI, supporting features like highlights and played-word tracking. Playback automatically resumes once the connection returns, ensuring a seamless and responsive listening experience. Ensuring precision through events A key part of making the Perch app player perfectly sync with the UI was using audio callbacks exposed by react-native-audio-api. Emitting precise events driven by audio layer for actions like track start, track end, or current position gives exact visibility into playback, lets progress bars stay perfectly in sync, schedules audio actions nearly frame-perfectly, and keeps the UI tightly linked to audio without lag or guesswork. Under the hood, our React Native Audio API library lets us queue and stitch smaller audio chunks with frame-perfect precision, ensuring play, pause, seek, and stop actions respond instantly – even in tricky situations like multiple 15 seconds seeks, resuming after a dropped connection, or handling multiple audio sources simultaneously. During our collaboration, we also focused on custom interfaces for working with audio buffers, making it easier for client’s developers to maintain and extend the system while ensuring playback accuracy. Together, these improvements create a highly reliable, precise, and maintainable audio system that supports both the user experience and developer workflows. Adding the currently played word tracking & highlighting to improve reading experience To provide a seamless experience whether app users read or listen, we also helped implement currently played word tracking, showing the currently spoken word in real time as audio plays. This allows users to tap any word and jump directly to that point in the audio, turning articles into interactive transcripts. This makes the app more interactive and helps with learning or following the content. To achieve this, we took a low-level approach that prioritized both time and memory efficiency, allowing us to handle thousands of individual words smoothly, without slowing the app, and enabling precise touch interactions, so tapping on a word feels accurate and responsive. But the improvements didn’t stop there. To help users save interesting words or passages to revisit later, we introduced custom highlights. They allow users to mark meaningful sections, while precise progress tracking ensures they can resume reading or listening exactly where they left off. The player is also resilient to connection drops: buffered audio continues uninterrupted, and playback automatically resumes when connectivity returns. This allows users to not only pick up where they left off but also revisit the sections they found most important. Playing well with the rest of the phone For Perch to feel truly native, the player needs to integrate smoothly with the wider device environment, ensuring audio coexists with calls, music apps like Spotify or YouTube, and other apps, pausing when required and resuming when the interruption ends. To achieve this, we implemented background and lock screen playback across both iOS and Android, complete with synced progress and controls. Thanks to React Native Audio API, we were able to unlock background mode, seamlessly manage lock screen state, and ensure Perch’s audio coexists smoothly with other apps on the device. The library also enables granular control over audio interruptions, letting us define precise behavior during system events like incoming calls or Siri activations. Additionally, we provided full support for headset remote controls – like AirPods gestures – so users can enjoy the same level of control they expect from their favorite native music or podcast apps. This technical foundation ensures a fully native, platform-compliant audio experience, delivering a premium and consistent user experience across devices. > "“Perch has been using react-native-audio-api for streaming generated audio in our app and it’s been fantastic. The audio quality is crisp and features like variable playback speed work seamlessly without any hiccups. We’ve replaced all other audio libraries we were using with it.”" > — Matt McGuiness, CTO at Perch ## Results Today, Perch users can open any content piece, hit play, and start listening to naturally sounding audio within milliseconds. The experience feels as natural as reading – and as effortless as pressing play on a podcast. Key highlights of our collaboration include: Reduced audio preloading time from ~10 seconds to ~1.5 seconds, delivering near-instant playbackEnsured reliable playback with smooth seeking, skipping, pausing, and recovery after interruptionsImplemented precise audio and reading progress tracking with interactive transcript features, including current word highlighting, auto-scrolling, tap-to-play from any word, and user-marked highlightsDelivered full background playback and multi-sound playback with React Native Audio APIOptimized AI playback speed for a better user experienceEnsured scalable streaming that efficiently handles articles of any length --- # Modernizing Photobucket's React Native App – and the Team Behind It Photobucket is a private space where people store their photos and videos, and revisit the moments that matter most. With hundreds of millions of images on the platform, Photobucket has offered a cross-platform React Native app experience since 2022. When they came to us, that app foundation – and the team behind it – was due for modernization. Their engineers were strong in React and largely comfortable with React Native, but the codebase had fallen behind on current best practices and hadn't yet taken advantage of the latest capabilities in the Expo ecosystem. They wanted to modernize that foundation: adopt the React Native New Architecture and Expo, strengthen the build and release pipeline, and build out the capabilities that would let the app grow – all without disrupting a team that would own the result long after our engagement ended. What started as a focused two-to-three month modernization and team-mentorship engagement grew into an ongoing collaboration. We became embedded members of their product team – shipping features, improving developer experience, and bringing a new design system to life. ## Services Performed - Mobile app development - Architecture modernization - Expo adoption (CNG & EAS) - Creation of EAS pipelines - AI/on-device inference - Performance optimization - Consulting & team education - Code review - AI engineering ## Tech Stack - React Native - Expo (CNG & EAS) - ONNX Runtime (Microsoft) - React Native Gesture Handler - React Native Reanimated - React Native Header Motion - RNRepo - Python - Claude Code - react-native-best-practices skills by Software Mansion ## Challenges & goals When Photobucket first came to us, their mobile setup had a few fundamental gaps to close: Their release process had no over-the-air update path, so every change (even a one-line JavaScript fix) required a full store release and review.Their React Native codebase had not yet adopted Expo's Continuous Native Generation (CNG) workflow, leaving native configuration fragile and unpredictable.A promising on-device face recognition proof-of-concept existed, but it still needed to be productionalized.The client planned to overhaul their design system, which would require rebuilding navigation and core components from scratch. Adopting Expo CNG One of our first tasks was moving Photobucket onto Expo's Continuous Native Generation workflow – not a straightforward search-and-replace. We started with a thorough audit of their native folders, mapping every manual configuration to either an `app.json` change, an existing config plugin, or a custom plugin we'd need to build. Multiple build variants – development, staging, and production – needed a dynamic app config that could switch targets based on environment variables. We also converted their internal native modules, originally implemented as legacy React Native bridge modules in Swift and exposed via Objective-C, to Expo Modules. This ensured CNG would work seamlessly and removed a whole class of build-time surprises. The benefits extended well beyond cleaner builds: with the codebase fully on Expo's workflow, the client team felt more confident adding native features without modifying platform files directly. Upskilling the Photobucket team along the way Embedded collaboration also meant making sure Photobucket's engineering team could benefit from our expertise in the React Native ecosystem and pick up more good practices along the way. We ran a continuous knowledge-sharing track alongside every phase of the project: regular code reviews with detailed written commentary on the patterns we noticed and how to improve them, observations shared in Slack as we worked, and a dedicated training session on React Native Reanimated – a powerful animation library that can hurt performance when misused. We made sure the team understood not just what we were building, but why we were building it that way, so they could carry that knowledge forward independently. Cutting build times from 45 to 15 minutes Adopting the React Native New Architecture and Expo CNG is the right long-term move, but the transition can push build times up before it brings them down – and during the work, Photobucket's Android builds climbed to around 45 minutes. We brought them back under control. Expo Application Services (EAS) got Android builds to around 22 minutes and iOS builds to 10, and RNRepo – our open-source tool for faster React Native builds – cut Android a further ~30%, to roughly 15 minutes. Faster builds are a direct developer-experience win: shorter feedback loops, less waiting, more shipping. The customer-experience win came from over-the-air (OTA) updates. For changes that live entirely in JavaScript – UI tweaks, bug fixes, or logic updates – there's no need to go through a store build or review at all. With OTA, these changes ship directly to users and reach them in minutes rather than the hours or days a full store release can take. By leveraging the Expo Fingerprint API, we built a pipeline that decides whether a given update should ship as an OTA, a store release, or both, with minimal effort from the people responsible for releases. We also made pre-release builds installable straight from a QR code. Every pull request to `main` triggers an EAS pipeline that produces a build or OTA update and posts QR codes directly in the PR as a comment, and every merge to `main` refreshes a set of development builds on the team's EAS profile (installable via QR code or Expo Orbit). Either way, anyone on the team – including non-technical stakeholders – can scan a code and test a change on their own phone within minutes, before it's merged, rather than waiting for a build to be distributed. Turning a FaceFinder proof-of-concept into a production feature Photobucket's FaceFinder lets users tag a person in one photo and automatically surface every other photo of that person across their Groups. The client had a fast, working proof-of-concept when they came to us; what it needed was to be turned into a production-ready feature. To make the right architectural decisions for production, we started with extensive benchmarking before touching production code. We compared multiple inference runtimes, face-detection approaches, and recognition models across accuracy, false-positive rates, and latency, giving the client team clear, data-driven evidence for every major decision. We evaluated both detector models and native platform solutions for locating faces in images, plus multiple recognition models for converting detected faces into the vector embeddings used to match people across their Groups. Beyond model selection, we improved the post-processing pipeline around face detection, optimized native inference performance on both iOS and Android, and wrote the native code responsible for fully local inference using ONNX Runtime. Once the benchmarks made the case, we settled on a recognition model architecture well-suited to production – one that performs reliably on real-world photos, handling variations in lighting, angle, and image quality. FaceFinder now runs entirely on-device – fast and accurate. A new design system and a carousel built with structured AI engineering Partway through our collaboration, Photobucket rolled out a new design system that changed the look and feel of the app entirely. We helped build it – creating the new navigation from scratch, new component primitives, and an integration with React Native Header Motion, a wrapper around Reanimated and Gesture Handler that makes animated header behaviors straightforward to implement. The most technically interesting part of this phase was the photo carousel: a full-screen, gesture-driven viewer with pinch-to-zoom, focal-point awareness, immersive mode, high-resolution image loading on zoom, overlay support, and animated headers and footers. It required us to get both the design and the business logic right while handling a number of subtle edge cases. We approached it with a structured agentic engineering workflow that kept quality high without sacrificing speed. Even with a detailed, well-documented vision for the carousel, Claude Code's initial output didn't reflect how we wanted to approach the architecture – and without a shared spec, there would be no reliable way to course-correct. So we invested more heavily in the spec upfront. The workflow and skills used Using the grill-me skill, we ran a structured interview session with Claude, feeding it all the design requirements and our initial architectural ideas, and letting it ask clarifying questions and surface edge cases we hadn't considered. At the end of that session, Claude produced a high-level spec and created eight separate spec files, one for each major component of the carousel: Virtualized pagerRoot carousel contextGesturesHeader and footerOverlaysMedia componentsZoom reactionsFullscreen takeover For each section, we opened a new Claude Code session – intentionally, to avoid context bleed between components – and ran another focused grill-me session on that section's details. Once the spec was solid, Claude implemented it test-first (TDD): writing tests, then making them pass. When a section produced visible UI changes, Claude used Argent, our agentic toolkit for iOS and Android applications, to validate the behavior on-screen before we moved on. After each section, we did a thorough human review pass. After all eight sections were complete, the carousel was working correctly with only minor polishing needed – a component built to spec, with full test coverage, using the right React Native primitives throughout. This workflow – human expertise guiding the spec, AI handling implementation, tight feedback loops at each stage – is something we're refining and bringing to more projects. It's not vibe coding; it's a structured, reviewable approach that produces code we're confident shipping. > "Software Mansion brought exactly the technical depth we were looking for. They helped us modernize our React Native app and leveled up our team in the process — by the time the engagement wrapped, we owned the work and the know-how behind it. A genuine partner, not just a vendor." > — Josh Gormley, VP of Engineering at Photobucket ## Results What began as a consulting and short-term modernization engagement became a long-running product partnership. Some of our favorite highlights: After modernizing onto Expo, we kept build times in check with Expo EAS and RNRepo – Android down to roughly 15 minutes (from around 45 during the transition) and iOS at 10 – a direct developer-experience win.With OTA updates, JavaScript-only changes now reach users in minutes rather than hours or days, instead of waiting on a full store release – a direct customer-experience win.We turned a proof-of-concept into a production-ready, fully on-device FaceFinder, backed by rigorous benchmarking for accuracy and performance.Installable QR-code builds let anyone on the team, including non-technical stakeholders, test changes before they're merged, tightening feedback cycles.We built a fully functional photo carousel using structured agentic engineering. --- # Developing a Medspa Platform That Contributed to 10x Client Growth Moxie helps over 700 independent business owners launch, run, and grow their medspas across the United States. When reaching out to us, the client’s vision was clear: to develop all-in-one software streamlining business management, cutting out inefficiencies and simplifying operations. We were excited to bring our expertise to the table to create a solution that removes the complexity of the legal, operational, and technical aspects of running a medspa. Along the way, we helped grow Moxie’s client base nearly 10x and improve platform stability to 99.85%. ## Services Performed - Product design - Web backend development - Web frontend development - QA & testing - Monitoring 3rd party integrations ## Tech Stack - Python - Django - PostgreSQL - Hasura - React - Next.js - TypeScript - Material UI - QA Wolf - Datadog ## Goals & challenges Before reaching out to us, Moxie would recommend its clients use a few applications to manage different aspects of medspa operations. However, juggling multiple tools and accounts proved to be inefficient and time-consuming for both Moxie's staff and clients. Moxie’s vision was clear: to develop an all-in-one solution named "Moxie Suite" that would significantly streamline business management. Initial goals of the project included: Building an MVP that would address the most pressing client needsSetting a scalable foundation for future growthBalancing stability and user-friendly design within strict medspa regulationsFocusing on stability and an intuitive design to meet user needs Building Moxie Suite:
the all-in-one medspa management platform When Moxie approached us, we knew the journey would be exciting, yet challenging. In just two months, we successfully delivered the MVP, laying a solid foundation for what would become an all-in-one medspa management platform. The MVP covered the essentials every medspa needed, including: Account creation and data managementAppointment booking and schedulingPre-appointment patient forms to simplify registration This is when the first major win came – the MVP enabled Moxie’s clients to move away from using multiple disconnected tools. Now, they could manage operations from one unified platform, saving both time and money. Following the MVP, we started working on key features to expand the platform’s functionality: Introducing an advanced invoicing system Running a medspa isn't easy, and many of Moxie's clients had to juggle scheduling, treating, and invoicing patients multiple times per hour (often single-handedly). To make billing easier, we built a user-friendly invoicing system that simplifies the process and allows invoices to be generated in just a few clicks. We started by designing the database models. One tricky requirement was adding a DRAFT invoice state where users could dynamically add products, services, and discounts, with subtotals updating automatically. Once the invoice was saved, the subtotals should remain fixed. Another challenge was navigating the complexities of the U.S. tax system and applying taxes correctly alongside discounts. During this process, we worked closely with Moxie to figure it all out and ensure the invoice system helps businesses stay organized, and offers a clear financial overview in one place. Integrating Stripe for smooth transactions To ensure the Moxie platform delivered a smooth and user-friendly payment experience, we integrated Stripe – a leading platform for processing online payments seamlessly and safely. To meet the specific needs of Moxie’s medspa clients, we used Stripe Connect and Custom Accounts, allowing each medspa to operate under its own account, all managed within a parent Moxie account. This configuration wasn’t without challenges and required careful consideration, as medspas often have complex legal and corporate structures depending on the US state they operate in. Finally, to make onboarding easier for medspas, we generated unique links that allowed them to complete the process directly in Stripe. Once everything was in place, we enabled payment collection using card-on-file, buy-now-pay-later, and cash payments, offering clients flexible and convenient options right from the start. Designing an intuitive booking flow We focused on creating a smooth, user-friendly patient booking flow that would make appointment scheduling a breeze. For the MVP, we partnered with Timekit, allowing providers to set their working hours, add ad-hoc time blockers, and define special shifts. Based on this information and existing appointments, clients could easily see and book available time slots. Our backend played a proxy role between the frontend and Timekit API, ensuring everything stayed synchronized and the booking flow worked seamlessly. This solution helped reduce administrative tasks, allowing medspas to focus more on their core services and enhance the experience for both staff and clients. In 2024, we decided to replace Timekit with a custom-built scheduling system tailored to Moxie’s needs. Within two months, we successfully developed an in-house solution that eliminated external bugs and reduced debugging time. This custom system has provided a reliable and scalable foundation for appointment scheduling, helping Moxie save thousands of dollars each month. Streamlining documentation for medspas As the platform grew, we collaborated closely with Moxie to design and build a medical documentation feature that would help medspas manage treatment records and stay compliant with US state and federal regulations. Thanks to this feature, each client’s intake and consent forms are tailored to the services they’ve booked. Patients can securely access their forms via a portal protected by an OTP (one-time password) sent to their phone. They can view and fill out the forms, while providers can review them, add notes, and request additional reviews from Medical Directors for Good Faith Exams (GFE). This system also extends to photos, diagrams, notes, and other charting information. To ensure scalability, we implemented signed URL uploads, allowing for the parallel upload of unlimited files without overloading the server. Additionally, we added a history tracking feature, enabling providers to see note edits and times. This has not only streamlined the documentation process but also provided a valuable legal backup for medical documents. ## Scaling for growth & improving stability When Moxie saw the growing demand in the medspa industry, its teams jumped in with both feet. In just nine months, the platform experienced 10x growth.  However, with this rapid expansion came the challenge of maintaining efficiency and scalability. The app had become central to the daily operations of hundreds of medspas, and any downtime could severely disrupt client workflows. To handle the growth, we focused on: Optimizing platform performance We implemented index-based pagination and used virtualization to render only the visible content on the page. We also analyzed our GraphQL queries and the SQL output from Hasura, eventually disabling the JIT compiler for PostgreSQL to improve query performance. Lastly, we introduced a Celery service to asynchronously process background tasks, improving overall system efficiency. All this to ensure the platform could scale effectively while maintaining stability and performance. Refining data management During the rapid development of the MVP, database design decisions were made quickly without full clarity on how the project or its clients' needs would evolve. However, after a few months of running the platform, we gained a clearer understanding of the direction the project was headed. This allowed us to refactor the database models to ensure better scalability in the future. As Moxie started introducing reporting features to analyze client data and spot market trends, we also began prioritizing database design, understanding data would be the foundation for all new features. Simplifying workflows As we gathered more feedback from providers, we were able to tailor the app’s UX to better suit their needs. We introduced global navigation with shortcut links to the most frequently used views in the app, streamlining everyday workflows. Instead of a long page with all the appointment details, we organized the information into tabs such as overview, client details, charting, GFE, and more. While we understand the importance of supporting the legal aspects of running a medspa, the primary focus for providers is patient care, not spending excessive time in the app. With that in mind, we made it a priority to simplify every workflow and reduce unnecessary steps, ensuring the app streamlines rather than interrupts core tasks. Improving stability Finally, to ensure the platform’s reliability, we focused on minimizing downtime and improving overall stability. We implemented real-time monitoring with Datadog, which allowed us to quickly identify and resolve performance issues as they arose. After experiencing several critical connectivity issues with Fly.io that caused hours of downtime, we decided to migrate the platform to AWS. This shift dramatically improved the platform's reliability, and since then, we’ve experienced no downtime due to infrastructure issues. We also teamed up with QA Wolf to run automated tests alongside manual ones during deployments, taking a proactive approach to catch potential issues before they escalated. For user-reported issues, we simplified the bug-reporting process with Bird Eats Bug, which helped our dev team efficiently track and resolve support tickets. All of these improvements have given Moxie the stability needed to scale with confidence  – the platform has maintained an impressive 99.99% uptime in 2025. > "“The team has maintained a high velocity over the course of the project, and has successfully implemented multiple projects with a very high degree of quality. They can be counted on as highly responsive, iterative, and able to deliver work with good velocity and high quality. Projects are implemented and completed on time. The team also excels at working in multiple time zones, including with engineers operating from other countries. Through their work, the platform has facilitated millions of dollars of revenue for our clients, and has been able to keep pace and growth with them. Every team member is outstanding, with a high degree of technical ability, great communication ability, and good work ethic and attention to detail. This is true of everyone, from our QA team to design to all of our engineers.”" > — Ryan Burbank, Head of Engineering at Moxie ## Results By building Moxie Suite from the ground up and continually improving its features and stability, we’re helping the client stay ahead of the competition in the medspa industry. In 2024 and 2025, Moxie focused on further simplifying the legal aspects of running a medspa. Its new Compliance Defender product has become a key market differentiator, and we’re proud to be part of this project. Key results of our cooperation include: --- # From Zero to 300K Users in One Year: How We Built an App That Builds Apps Vibecode is a platform that lets anyone create, develop, and launch fully functional mobile & web apps directly from their phone or web app by interacting with LLMs in natural language, without having to learn any coding skills. The Vibecode team came to us with an early prototype and a clear ambition: make mobile app creation accessible to everyone. We worked together to define the right technical approach and develop core features of their iOS app. The result? A platform used by hundreds of thousands of people. ## Services Performed - Mobile app development - Consulting & architecture - Prototyping & PoC - Web app development ## Tech Stack - SwiftUI - React Native & Expo - Express.js - Next.js ## Goals & challenges When the Vibecode team first reached out to us, they had an early prototype and a clear vision. What they needed was a reliable team to turn that vision into a scalable product. Our first contribution was consulting to identify the right technical approach tailored to the client’s business needs. From there, we moved on to: Building a working PoC that validated the core approachExpanding the app's functionality and implementing new designsResolving critical technical challenges as the platform's priorities often changed due to the innovative nature of the project Finding the right approach and building the PoC Before writing a line of production code, we needed to answer a key question: “What’s the right way to build the proof of concept in this case?” Our first instinct was to explore adapting Expo Go as the foundation. As a mature, well-maintained tool built exactly for running Expo apps, we treated it as a natural starting point. But the more we dug in, the clearer it became that working within such a large, complex codebase would create many unnecessary problems and the overhead simply wasn't worth it. Vibecode had already built their own prototype using expo-dev-launcher and expo-dev-menu, which we used for a while. However, it eventually proved to be the wrong approach as we started to encounter issues stemming from running multiple concurrent React Native runtimes inside a single app – a real risk in a product where users are constantly generating and previewing new apps. From there, we landed on what turned out to be the right call: build a native iOS app and embed the generated Expo app within a SwiftUI view. This architecture meant we were working with a clean, controlled environment. We also enabled certain debug-only React Native features selectively to improve stability and user experience where it mattered most. In parallel, we built an Android prototype, however, it was later deprioritized to concentrate resources on the iOS app and move faster where the product had the most traction. Building the native iOS app With a solid foundation in place, we moved into building out the iOS app, namely expanding its functionality, implementing new designs, and steadily improving stability along the way. We did our best to make the app feel and look great: we polished the UX with haptics and tooltips, optimized navigation, implemented authentication, an API client layer, and more. Embedding React Native into the iOS app Given the nature of the product, it was especially important to ensure that dynamically generated React Native applications run reliably and are displayed smoothly within the native iOS app. This wasn’t a standard scenario where we needed to add React Native to an existing app – it was closer to embedding a sandbox for user-generated apps, where the debugging functionality had to be enabled in the released version of the app. We approached this by integrating React Native into the SwiftUI-based architecture in a controlled way, treating it as a contained execution environment. This allowed the native app to remain the source of truth for navigation and system-level behavior, while React Native handled the dynamically-generated UI experiences. Since users were effectively generating and running their own apps, we needed to ensure that React Native errors wouldn’t break the host application or leave users without feedback. That’s why we implemented error capturing that translated runtime issues into user-friendly states, allowing the app to recover instead of failing silently or crashing. We also patched Reanimated behavior so that runtime errors in release builds could be properly surfaced, improving reliability in production scenarios where debugging visibility is otherwise limited. Another critical challenge was how JavaScript bundles were delivered and resolved. Because apps were being generated and executed dynamically, bundle loading needed to be both fast and predictable. In addition to loading bundles via Metro, we introduced logic for loading static JS bundles, significantly improving cold start times. We implemented a custom TurboModule responsible for resolving static JS bundle assets, alongside a dedicated flow for fetching and caching bundles. This ensured that the correct version of each generated app was consistently loaded. As the platform introduced more advanced features, we also needed a way to expose selected backend capabilities to the generated apps. To support this, we built a proxy layer for requests originating from the React Native runtime. This allowed the native layer to mediate access to API integrations tied to user subscriptions, ensuring that permissions were enforced consistently while keeping the JavaScript environment isolated from sensitive logic and credentials. Finally, we helped improve the user experience around the tooling stack. Metro bundler caching and resolution issues were affecting iteration speed and predictability, so we helped stabilize these workflows and reduce friction during prompting. These improvements made a real difference in Expo-based setups generated by the platform, cutting startup times by as much as 8x. Implementing AI agent chat integrations As the chat interface became the main control surface for building apps, we extended it with tools that made iteration more direct and precise. One of the additions was the Element Picker, which allows users to click on specific UI elements inside their running app and request changes through chat. This was powered in part by React Native’s Element Inspector, which we integrated into the system to expose structured UI metadata back to the agent. We also added a Prompts tab, making it easy for users to track and reuse previous instructions and iterate more smoothly while building their app. Adding iOS native extensions To make Vibecode feel like a truly integrated part of the iOS ecosystem, we expanded the product by introducing several native extensions that connected generated apps more directly with the operating system. We started with a home screen widget called Apps Launcher, which lets users quickly access and launch their generated projects directly from the iOS home screen. This significantly reduced friction and made the experience of switching between apps feel native. We also introduced iOS App Clips, enabling users to open and interact with shared Expo projects without needing to install the full application. This was particularly valuable for the app’s organic growth, allowing users to experience generated apps instantly from a link. To further improve visibility into long-running processes, we added Live Activities that display real-time progress of app generation. Thanks to it, users can track the state of their builds directly from the lock screen or Dynamic Island. Last but not least, we integrated App Intents so generated apps and platform features can be exposed to iOS in a more native way, enabling interactions through Siri and system-wide shortcuts. Developing the web app As Vibecode grew, the web app became a key part of the build-and-ship workflow rather than just a companion to mobile. We integrated Expo Launch, allowing users to take their generated apps all the way to App Store submission directly from the web. We also added iOS Simulator previews in the browser, moving beyond basic Expo web-based previews and giving users a more realistic environment to test their apps. To improve the chat experience, we introduced Server-Sent Events (SSE) to stream AI responses in the web app, providing real-time feedback as the app is being created. The recipe to success? Shipping fast without creating technical debt At Software Mansion, we use AI to move faster without compromising quality. When working with Vibecode, we always treated AI as an accelerator for iteration and product exploration, while keeping the underlying architecture strict, predictable, and production-ready. We focus on delivering codebases that growing client teams can confidently inherit and extend. That influenced how we structured the React Native, native iOS, and web layers, keeping clear boundaries and avoiding shortcuts that would make future development harder as the product scaled. Last but not least, even when features are created with the help of AI workflows, we always ensure the underlying systems are designed to remain stable, maintainable, and easy to reason about as the platform evolves. > "Software Mansion are the best React Native developers. They worked seamlessly as an extension of our team and helped us navigate the complexities of building the first ever mobile app that built mobile apps. I had a great time working with everyone on their team, and we hope to work with them in the future." > — Ansh Nanda, CEO at Vibecode ## Results Throughout our cooperation, we helped take Vibecode from an early prototype to a product used by hundreds of thousands of people. 300,000+ registered users within the first year250,000+ lines of code merged across mobile, web, and backend systemsFeatured by Anthropic as a flagship Claude-powered product --- # Optimizing Battery Usage & Improving Crash-Free Rate for the Boating Community SeaPeople was born from a group of avid boaters who spotted a gap in the boating community and decided to fill it by building an app to connect users, share sea stories, and stay in touch. When SeaPeople came to us, its MVP had a strong foundation on iOS, but the Android version hit rough waters with noticeable performance issues and some features not working as expected. The client turned to us for help, tapping into our expertise as core React Native contributors and Expo co-creators. In just over three months of collaboration, we built a solid foundation for the app’s future growth, improving its crash-free rate to almost 99% and introducing new social features. ## Services Performed - Mobile app development - Bug fixing & performance optimization - Support & stability monitoring ## Tech Stack - React Native - Supabase - Sentry - Expo - RN Reanimated - RN Gesture Handler - RN Screens - RN Gifted Chat - RN Maps ## Challenges Our initial goal was to bring the SeaPeople Android version up to the same high standard as iOS, tackling challenges like: Frequent crashes during background tasks, like location trackingCross-platform inconsistencies, leaving Android users with a subpar experienceAlong the way, we noticed significant battery drain on both Android and iOS, making the app unreliable for longer trips ## Getting in the same boat with SeaPeople Working with SeaPeople was more than a technical partnership – it was about understanding the boating community’s needs. Together, we set our sights on creating an app that would feel like second nature to sailors and boaters. Boosting stability When SeaPeople approached us, the Android app version faced frequent crashes, particularly during route tracking. Users who started recording a route and reopened the app after it had been running in the background often found themselves stuck in a restart loop. We found the problem stemmed from Android’s headless mode, which conserves battery by running apps without a visible UI. A flaw in the background process logic triggered resets whenever no active UI was detected. To resolve the issue, we first had to replicate it. This required background location tracking to be processed during the transition from headless mode to regular mode. Improving the crash-free rate demanded refining the app’s task-handling logic to prevent unnecessary resets in headless mode. But the root of the problem was deeper than expected – it was tied to the crucial Expo Task Manager package. We quickly identified the issue and solved it, ensuring the SeaPeople app became stable as soon as possible. After just three months of cooperation, the app’s crash-free rate increased from 95% to 98.5–99%, ensuring a far more reliable UX. > **Need a hand with your Expo project?** > With over 2,500+ pull requests since 2017, we’re the top contributing group to the Expo ecosystem, crafting key components that power nearly every React Native app out there. Navigating global header troubles After improving stability, we faced another challenge: the Android app headers were getting stuck behind the top bar, making them inaccessible to users. At first, the problem seemed simple – one of the screens had two headers. Many would think it could be easily fixed by removing the redundant header, but we quickly realized the problem was global and needed more attention. While the first header was a default for basic navigation, the second was dynamic, with custom actions. What’s more, the dynamic header was generated using a setTimeout function. This caused the header to load with a delay, introducing unnecessary lag, re-renders, flickering, and occasionally crashing the screen. So, we found it necessary to develop a global header component. By using a custom header component with direct props for the left and right components, we were able to eliminate the delay and improve performance. Thanks to it, the headers started rendering instantly, improving app speed, reliability, and overall performance. The global header component was designed to support personalized actions while keeping a consistent look and behavior across the app. Unlike the previous implementation that used setTimeout, this solution eliminated screen loading issues, ensuring a smoother user experience across the application. Refactoring navigation Since the client wanted to hide the navigation bar on certain Android screens to match the iOS experience, we had to overhaul a significant part of the app’s navigation system, using the React Navigation library. Given the complexity of the app and the large number of screens, the risk was high – one wrong move could break the navigation, causing app malfunctions or crashes. With the above structure, the tab bar remained visible on the profile and settings screens. To show the tab bar only on the home, feed, and notifications screens, we needed to adjust the navigation structure. The simplest solution was to nest the tab navigator inside the first stack screen, instead of nesting stack inside the tab navigator. We began by testing the new navigation on a few screens to ensure the tab bar hid correctly without causing any issues. Once we had a stable solution, we presented it to the SeaPeople team and gradually rolled out the changes across the app, carefully monitoring for any unexpected behavior and making sure the app performance remained intact. Optimizing battery usage One of the main challenges when we started working with SeaPeople was the excessive battery drain on both iOS and Android which was super problematic as many users rely on the app for extended trips. At first, we assumed the issue stemmed from GPS tracking, so we introduced three tracking modes with varying levels of GPS accuracy to save battery. However, despite these adjustments, battery consumption remained roughly the same, while tracking accuracy dropped significantly. Realizing the problem extended beyond GPS, we dug deeper into the app performance. After profiling it, we found that high CPU usage continued even with minimal activity, and we discovered one of the screens was re-rendering every second, causing CPU spikes even when the screen wasn’t visible or the app was running in the background. Additionally, the app was constantly making network requests to the local database, regardless of GPS mode or location updates, leading to battery drain. To address these, we minimized re-renders by ensuring invisible screens wouldn’t update and we optimized the re-render process, reducing CPU usage from 170% on an iPhone 13 to 30%. We also implemented a system to query the database only when new location data is available, cutting down on network requests and improving battery life. This also allowed us to fix a few visual bugs that showed up occasionally. Introducing new social features To boost user engagement, we collaborated with the SeaPeople design team to introduce the Groups feature, enabling users to connect, join communities, and share posts.  The project began with a broad scope and a tight deadline. Within just two weeks, our two-person dev team delivered the initial version, followed by extensive testing to resolve any issues. Building on existing features like messaging and post feeds, Groups took the in-app social experience to the next level, allowing users to form groups, share updates, 
and communicate with ease. > "“The effort to make it fast on both platforms and work around platform specific issues was beyond our skillset. The team at Software Mansion jumped in, onboarded very quickly, and made an impact right away. The contacts with the maintainers of core RN libraries was extremely valuable. We couldn't have shipped without their help.”" > — Jean-Michel Lemieux, Co-Founder at SeaPeople ## Results Throughout our collaboration, our developers worked closely with the SeaPeople team, providing input on the technical feasibility of proposed changes and evaluating the trade-offs between feature complexity and potential value.  In just over three months of collaboration, we built a solid foundation for SeaPeople’s future growth. The app stands out with its sleek design and interactive features, integrating a range of complex React Native components. --- # Cutting Live Broadcast Latency From 7 to 2 Seconds for a Group Chat App ChatBCC is an invite-only community app where actors, reality stars, and athletes host group chats and talk directly with their fans. The product was built around chat, and it worked well for that. But hosts kept asking for a way to go live together, talk with their community in real time, or react to a new episode moments after it drops. We worked together to build Live Spaces with Fishjam, our multimedia hub solution. Using Fishjam, we were able to reduce broadcast latency from 7 seconds to around 2 seconds while lowering costs by roughly 40% compared to market alternatives. ## Services Performed - Mobile app development - Backend development - System architecture - Real-time video integration - Performance optimization - UX/UI improvements - App Clip implementation - Observability & triage ## Tech Stack - Fishjam multimedia hub - React Native - React - Apollo GraphQL - Swift - Kotlin - GraphQL - TypeScript - React Router ## Challenges & goals Building Live Spaces meant introducing an entirely new product category within ChatBCC. To make it right, together with ChatBCC, we rethought the underlying infrastructure, data consistency model, and the entire session lifecycle. During our collaboration with the client, we aimed to give hosts a new tool for engaging communities, drive new membership growth, and tie live sessions into the existing message system. For this to happen, we focused on: Evaluating and choosing the right broadcast stackComposing multiple host streams into a single viewer feed without ballooning infrastructure costsMaintaining state consistency across four separate systems: Fishjam, the compositor, the mobile app, and the API layer. Building and benchmarking three PoCs of Live Spaces in two weeks Live Spaces is a real-time video session built directly into a ChatBCC room – hosts broadcast live to their members, viewers watch and react, all without leaving the community where the conversation happens. Before implementation began, we worked together with ChatBCC to evaluate different architectures for Live Spaces and identify the solution best suited to their product and business goals. One of the options we considered was Fishjam – our multimedia hub built and maintained as a commercial product. It provides a complete real-time media stack, including a WebRTC SFU, server-side compositing, and broadcast capabilities. Together, we decided to build and benchmark Fishjam and LiveKit side by side under real-world conditions to make a data-driven technology decision. The architecture assumed two distinct delivery paths: WebRTC for communication between participants hosting the session, and LL-HLS via MUX for distributing the stream to viewers at scale. The initial evaluation focused on two variants: LiveKit + MUX (LL-HLS delivery)Fishjam + MUX (LL-HLS delivery) Within two weeks, both implementations were running and ready for comparison. The primary evaluation criterion was latency between participants hosting the live session and viewers watching and interacting through comments and reactions. During testing and demos, together with the client, we observed approximately 7 seconds of end-to-end latency in both variants. Since participant-to-participant communication used WebRTC and remained near real-time, the bottleneck was clearly the LL-HLS delivery path through MUX on the viewer side. Based on these findings, we proposed a third approach that removed MUX entirely and relied on Fishjam's WebRTC-based delivery end to end, enabling significantly lower participant-to-viewer latency and a more interactive live experience. Thanks to Fishjam, the client was able to reduce the latency to ~2 seconds. Cost was another advantage of our multimedia hub. Here’s a simple breakdown and comparison for a reference session (60 minutes, 3 hosts, 500 viewers, streamed in 720p resolution at 2 Mb/s): Fishjam: ~$20Fishjam + MUX: ~$33.50LiveKit + MUX: ~$34 Fishjam made it possible to reduce the broadcasting costs by ~40%. For a platform where live sessions happen regularly across many host communities, that difference adds up fast. How Fishjam handles compositing and broadcast Fishjam takes the audio and video streams from all hosts and combines them into a single broadcast stream that can be delivered to viewers at scale. The key thing is that compositing isn't a separate service or a piece of custom infrastructure; it's built directly into the Fishjam platform. Layouts, speaker tiles, VAD speaking outlines, avatars, names, mic/cam state, and even different broadcast and recording variants are configured in backend code, applied by Fishjam’s compositing service and distributed through its broadcasting capabilities. For the ChatBCC team, this meant they didn't have to spend engineering time building and maintaining complex multimedia backend infrastructure. Instead, they could focus on developing more cool product features. With most of the heavy lifting handled by Fishjam, the integration is simple and lightweight while enabling low-latency, cost-effective live streaming at scale. Working directly with the creators of the tool makes all the difference Throughout the project, we worked closely with both the ChatBCC team and the Fishjam engineers, allowing us to iterate on the compositing capabilities that power Live Spaces. When something didn't work, we could simply talk to the engineers building Fishjam and work through issues together. One example worth mentioning was conference room stability. After significant debugging, we traced the root cause to the SDK level – something that couldn't be patched from JavaScript. The fix ultimately required changes to the underlying WebRTC implementation and close collaboration with Fishjam's core team. That kind of access simply isn't available when you're a customer of a third-party platform. Keeping four systems in sync The Live Spaces feature has a lifecycle: green room, going live, multi-host transitions, recording, teardown. At every stage, API layer, Fishjam, the compositor, and the mobile app need to agree on what's happening, but in production, they don't always get the memo at the same time. We noticed that some of the most challenging issues only surfaced under real-world conditions and were difficult to spot in development environments. For example, on iOS, moving the app to the background could permanently disable the camera due to differences in how production and development builds handled app lifecycle/state. In another case, an incoming alarm or phone notification at the exact moment a user joined a room could leave audio in a broken state. We also investigated numerous reports of microphone failures that ultimately turned out to be caused by unexpected interactions with Bluetooth audio devices. Resolving these issues required analyzing how the application behaved across different devices, operating systems, and real-world user environments. Many of these issues only surfaced under production conditions, which is why we dogfooded the feature internally, running team syncs through the app to uncover edge cases long before they reached users. Our approach to testing a real-time product The Live Spaces feature couldn't run in a simulator, so development and testing had to happen primarily on real devices. To speed up iteration, together with the client we decided to try out SimCam, our tool that emulates a camera feed within the iOS Simulator, allowing us to test video workflows without constantly setting up physical hardware. We also worked on refining cross-platform audio – since iOS and Android expose different audio session APIs, they behave differently when it comes to device switching, echo cancellation, and background modes. To ensure a consistent experience across both platforms, together with the client we decided to use customized fork of React Native WebRTC, which provides native modules for iOS and Android. ## Results We worked with ChatBCC to take Live Spaces from an idea to a complete, low-latency, and affordable real-time media pipeline. Some of the highlights of our collaboration include: ~2s broadcast latency achieved with Fishjam (down from over 7s initially)~40% lower broadcast cost per reference session3 comparative PoCs delivered in just 2 weeks to allow the client to make a data-based architecture decision70+ merged PRs and 15,128 lines of code on mobile70+ merged PRs and 16,974 lines of code on backend --- # Optimizing Performance and Building a Rich Text Editor for a Chat Platform Filament is an invite-only platform designed to give users a space to connect and chat, allowing them to network across professional groups. The client reached out to us with three initial projects in mind: supporting iPad layouts in their mobile app, building a truly native React Native rich text editor, and improving performance on Android. During our collaboration, we reduced Android cold-start time from 6–10 s to under 1 second. We also worked on the client's web platform and notification system. ## Services Performed - Mobile app development - Performance optimization - Web development - App Clip development - Custom library development - QA ## Tech Stack - React Native - JavaScript - Rust - React - TypeScript - Kotlin - Swift - Objective-C ## Challenges & goals Filament had clear goals for improving their platform across devices and ensuring smooth networking experiences. Together, we aimed to: Reduce Android cold-start time and improve overall app performanceEnable consistent, cross-platform experiences on iOS, iPad, Android, and webBuild a high-performance, native rich text editor for structured messaging Supporting iPad layouts in the existing mobile app We started our collaboration with a goal to extend the client’s existing mobile navigation to tablets – a first step that laid the groundwork for supporting the web. Unlike mobile-only chat apps, Filament’s vision was to let users comfortably switch between conversations, loops, and sidebars on wide screens – similar to a desktop-style split pane layout. To achieve this, we built a dedicated navigator optimized for wider screens. It supported up to three panels side by side, persisting content on the primary panel when switching tabs. This approach gave users a more fluid, desktop-like experience. Supporting a split-pane UI required modifying some components to scale across screen sizes, adapting navigation stacks to work with nested navigators, and styling desktop-style panes so they matched the client’s designs. Certain screen-level features, like lightboxes and presentation sheets, also had to be rethought for larger formats.  From the beginning, we emphasized reusing code across mobile and desktop, which laid the groundwork for consistent cross-platform development. Cutting Android startup times When we first began working with Filament, their Android app took from 6 to even 10 seconds to launch cold – a delay long enough to discourage new users before they even sent their first message. So, we set out to analyze and optimize the startup flow.  Our performance analysis pointed to three major issues: oversized JavaScript bundles, use of libraries that weren’t optimized for native platforms, and slow secure token storage caused by the chosen encryption algorithm. To address these, we: Replaced the encryption algorithm used in secure storage, which had been a hidden bottleneck, but only on certain devices. This allowed us to cut cold-start time on Android from 6-10 s down to ~2 s.Reduced the JavaScript bundle size to shorten parsing and evaluation during startup.Replaced the app’s syntax-highlighting library, which wasn’t optimized for mobile, with a custom React Native wrapper that ensures only a single engine is initialized instead of several competing ones. This further decreased app startup time on test devices from ~2 seconds to just 800–900 milliseconds. Not only did these activities improve app performance on Android, they also removed a major barrier to adoption, making the Filament app feel instantly responsive and ready to use. Bringing truly native rich text editing to the React Native community Messaging apps live or die on their input fields, and Filament’s users needed more than plain text – mentions, styled text, inline formatting, and structured output were all must-haves. The client’s first approach, using an existing tool to provide rich WYSIWYG style text editing, quickly proved limiting. It was slow to mount, introduced inefficient scrolling and keyboard interactions, and made even basic styling difficult, since all CSS and fonts had to be pushed into the WebView. Together with Filament, we decided to start fresh and build something fully native the client and the entire open source community would benefit from. This is how react-native-enriched was born. At its heart is EnrichedTextInput, a fully native text input component that brings: High performance thanks to direct interaction with platform components (no unnecessary state or prop overhead)Synchronous text styling, so formatting updates feel instantLive style detection and HTML parsing, making rich content easy to handleCustomizable styling, fitting any design systemSupport for mobile apps using the New Architecture EnrichedTextInput is uncontrolled, meaning it doesn’t use state or props to store its value. Instead, it communicates directly with underlying platform-specific components, keeping typing buttery smooth while offering advanced features. By sponsoring this effort, Filament not only refined their product but also contributed greatly to the React Native ecosystem. We hope the library will soon stand as a building block for any React Native team needing structured, styled text input. Working on the web platform Filament wanted to bring to life a browser version of the app and focus on truly multiplatform support. By reusing much of the existing mobile platform logic, we were able to deliver the same core experience on the web. Along the way, we needed to switch the bundler from Webpack to Metro, which unified builds across mobile and web and unlocked smoother cross-platform development.  We also addressed library compatibility issues, ensuring that dependencies worked reliably in both mobile and browser environments. Finally, we focused on certain platform-specific features that needed tailored implementations: for example, photo uploads rely on native pickers on mobile, but on the web we had to implement a drag-and-drop interface, preserving the same user experience in a way that made sense for each platform. Thanks to these improvements, Filament achieved a single codebase spanning iOS, Android, iPad, and web, giving users the freedom to stay connected wherever they prefer to chat. Streamlining onboarding with App Clips As already mentioned, Filament is an invite-only platform, so joining the app starts with an invitation link. Originally, new users had to manually copy their invite code from an email or web page into the app after downloading, which created a negative first impression. To simplify this process, we introduced App Clips on iOS and Google Play Referrer parameters on Android. Thanks to these, even first-time users who click an invite link can install or open the app directly from the link, have their invite code automatically pre-filled (eliminating the need for copy-paste) and smoothly move from the invitation to an active conversation. Ensuring reliable notifications In a chat app, slow or missing notifications can quickly frustrate users. Filament faced a particular challenge on Android, as incoming messages were encrypted, so they had to be decrypted before they could be displayed. Originally, the app relied on Expo Notifications.  The problem was that processing each notification on Android – even when the app wasn’t running or was in the background – required launching the full JavaScript runtime, including parts of the code that weren’t needed. On slower devices, this frequently exceeded Android’s 20-second processing limit, which caused notifications to be dropped. To solve this, we built a fully native notification handler for Android. It processes messages quickly while still handing over interaction logic (such as tapping on a notification) to JavaScript, preserving flexibility without sacrificing speed. This effort also highlighted another technical need: Filament’s Rust library, which powered message decryption, originally only generated bindings for JavaScript. We refactored it to support both JS and native layers, allowing the native notification handler to decrypt messages efficiently. At the same time, we switched from static to dynamic Rust library linking, reducing the Android app size by roughly 30%. ## Results Our continued collaboration with Filament focuses on concrete technical goals: improving app performance, enabling cross-platform support, and improving the user experience.
In just a few months, we: Cut Android cold-start time from initial 6-10 s to ~800 msBuilt a multi-panel navigation system for iPad, macOS, and webUnified bundling logic across mobile and webReduced Android app size by over 30%Streamlined invite-only onboarding with App Clips and Play Store parametersDelivered reliable, encrypted push notificationsDeveloped React Native Enriched – a fully native rich text editor for React Native --- # Refining an Event Planning App That Won Google Play’s Best App Award Partiful streamlines event planning with a perfect mix of fun design and practical functionality. Millions of people use it to plan everything from birthdays and house parties, to casual hangouts and major celebrations. With customizable invites, easy RSVP tracking, and fast communication with Text Blasts, Partiful brings everything you need to plan an event into one place. The client was looking for experts to improve the functionality of their Android app, focusing on design, stability, and usability. We joined the project, recreating Android-specific features, helping to increase user engagement, and improving retention to drive more downloads. Partiful has been named App of the Day by Apple multiple times and was a finalist for Apple's Cultural Impact Award in 2024. That same year, it won Google Play's Best App award. More recently, the team was recognized by Fast Company as one of the most innovative companies in social media. In 2026, Partiful was listed as one of the top 26 apps for 2026. ## Services Performed - Mobile app development - Bug fixing - Performance optimization ## Tech Stack - React Native - Expo - RN Reanimated - RN Gesture Handler - RN Screens - SwiftUI - Kotlin - OpenGL ## Challenges Partiful came to us with a clear mission: to expand the React Native iOS app and improve the Android app. The goal was to achieve feature parity across both iOS and Android, delivering a consistent user experience. However, this presented several challenges such as building custom transparent videos or recreating iOS-specific features like blur effects. Recreating blur effects on Android To ensure feature parity across platforms, we needed to recreate the blur effect on Android. What seemed like a straightforward task presented unexpected challenges. Blur effects feature prominently throughout the Partiful app, appearing in everything from modals to full-page backgrounds to buttons. Since React Native didn't natively support blur effects on Android, replicating this effect using existing tools proved to be more complex than anticipated. We worked closely with Partiful’s design team to find a solution. As the app was already using ExpoBlur, we tried using a native blur view based on the BlurView library. However, BlurView was still experimental on Android and caused numerous issues like unblurred text, white flashes, or poor performance. On top of that, it took screenshots of the content and applied the blur afterward, draining excessive resources. Due to tight timeline, we evaluated alternatives to blur, including solid colors, textured backgrounds, images, and various gradient types. For image blurring, we leveraged the built-in cross-platform blurRadius property. Ultimately, Partiful selected the linear gradient approach, as it was straightforward to implement, maintained performance efficiency, and delivered a visually appealing, stable, and responsive solution. Bringing transparent video to Android To give Android users the full app experience, Partiful wanted to bring over the transparent video effect from iOS. Since existing solutions didn’t cover this in React Native, we helped build it natively for Android. The first hurdle was ExoPlayer, the video player behind react-native-video and expo-video, which doesn’t support alpha-channel videos. This meant high-quality transparent videos couldn’t retain their transparency. We solved this by extracting the alpha channel from RGBA videos and merging it with the color video for seamless playback. Next, we helped tackle Android implementation. The key was a custom TextureView to overlay the video’s bottom half transparently while displaying the top half normally. We used OpenGL to render the videos, but setting up the EGL context took extensive iteration to ensure everything worked without missing a beat. Once we had transparent videos rendering natively, we helped Partiful build an API to connect the native views, video player, and React Native’s JavaScript code. The cherry on top? Transparent videos run on the GPU, meaning all the heavy lifting is handled by the graphics card instead of the CPU, keeping the app fast and efficient. Developing Live Activities on iOS After fine-tuning the Android app, the client decided to keep the momentum going and asked us to add Live Activities to the iOS app version. Live Activities is Apple’s interactive notification feature that shows real-time updates, such as event location, date, or time, directly in Notification Center and the Dynamic Island. Since this feature requires iOS native code in Swift and SwiftUI, we integrated it into React Native by creating custom native modules. We focused on: Implementing a WidgetKit extension for Live ActivitiesUsing SwiftUI to design the UI of Live ActivitiesDeveloping a native module to trigger and update Live Activities based on events or notificationsPerforming end-to-end testing to ensure seamless performance across all targets This allowed us to bridge the gap between JavaScript and iOS components, ensuring smooth real-time updates and UI synchronization. Creating an App Clip for iOS to delight new users To expand Partiful’s reach and drive more downloads, we developed an App Clip – a lightweight, sub-50MB version of the app designed to provide quick access to essential features. The main goal of the App Clip is to deliver an app-like experience for users who don't have the Partiful app: a snappy, delightful, full-screen interface that doesn't require an app download. For hosts creating events on Partiful, sending their guests an invite that renders as an App Clip creates a "wow moment" that drives excitement for the party. Guests can quickly view event details and confirm attendance, getting a taste of the app's value. As building the App Clip required creating a separate navigation stack, we replicated the navigators from the main app to maintain a seamless user flow. This way, we ensured a consistent user experience across both the App Clip and the full app version. Context refactoring for improved app performance We helped Partiful identify performance bottlenecks in its monolithic data structure. This single, large context caused frequent re-renders whenever components accessed shared values, slowing down the app. To address it, we recommended refactoring the context, splitting the monolithic structure into more manageable modules. The goal was to reduce unnecessary re-renders by isolating specific data into their own contexts. With clear guidelines provided by the client team, we helped implement a modular architecture, making the app more responsive. As a top contributor to Expo, we also supported Partiful in optimizing Expo upgrades, ensuring smooth integration across workspaces and contexts, which made the app more maintainable and scalable. > **Need a hand with your Expo project?** > With over 2,500+ pull requests since 2017, we’re the top contributing group to the Expo ecosystem, crafting key components that power nearly every React Native app out there. ## Results The Partiful app takes event planning to the next level with its vibrant design and playful features.  Throughout our cooperation, we significantly improved the performance of Partiful’s Android app. By introducing features like blur effects and transparent videos on Android, along with Live Activities on iOS, we helped the client boost user engagement and improve the overall UX. Key results of our cooperation include: --- # Modernizing Real-Time Infrastructure and Improving Observability for Supabase Supabase is an open-source platform built on Postgres that provides developers with authentication, instant APIs, edge functions, real-time subscriptions, and more. We collaborated with the Supabase team to support two parallel efforts: modernizing the Realtime.js SDK to use the Phoenix.js implementation and delivering performance and reliability improvements to Logflare – an observability tool used for processing logs and metrics at scale. ## Services Performed - Consulting - SDK modernization - React Native integration - Elixir backend development - Testing infrastructure development - Architecture development - Open-source contributions - AI engineering ## Tech Stack - TypeScript - JavaScript - React - Elixir - React Native - Phoenix - Vitest ## Challenges & goals Supabase approached us with a goal to improve the reliability and maintainability of their Realtime.js solution while ensuring it remains easy to use across different environments. Alongside, the Logflare system required a few improvements in performance and scalability, especially around log ingestion and processing. Together, we worked on: Rewriting Realtime.js to Phoenix using AIReducing the need to maintain custom forks of underlying librariesEnsuring the SDK works reliably across web and mobile environmentsDeveloping testing strategies for a library-based ecosystemOptimizing key parts of the logging pipeline Throughout the process, we collaborated through pull requests reviewed by the Supabase team. That meant quality had to be high from the start, with no room for cutting corners and fixing things later in private. Realtime.js: modernization and the Phoenix implementation Realtime.js is the part of the Supabase SDK that handles real-time functionality: broadcasting messages to channels, subscribing to database changes, tracking presence to know which users are currently active, and many more. Under the hood, it uses WebSockets via Phoenix.js. Over time, Supabase had developed a fork of Phoenix.js that diverged considerably from the upstream library. Maintaining that fork had become challenging, and the team wanted to move to using the canonical Phoenix.js implementation directly. But before committing to a full migration, they needed to know whether it was even possible – and that's where we came in. Building the proof of concept We started with a PoC. The client trusted us to make the right technical calls and check in with updates. That trust set the tone for our whole collaboration. One of the first things that became clear was that Phoenix lacks proper type definitions. The library used JSDoc comments – and some of those comments referenced types that didn't exist, or described functions vaguely. We worked through them carefully, using AI to write correct type definitions and keeping the changes as minimal as possible so that integrating future Phoenix.js updates would be straightforward. After roughly one and a half months, the PoC – covering all key functionalities – confirmed that the migration was viable, and the client asked us to proceed with the implementation, focusing on improving code quality, fixing types, updating unit tests, and ensuring the API looks the same. Working on the full implementation The central benefit of moving to Phoenix.js was a shift in responsibility: the WebSocket connection layer now belongs to the Phoenix.js project. This means that instead of owning a diverging fork, Realtime.js became a wrapper: cleaner, lighter, and easier to keep current going forward. The main constraint we worked within was that this change couldn't be visible to developers using the SDK. The API had to look and behave the same. To achieve that, we built an abstraction layer over Phoenix.js, aligning function names and call signatures where possible so that existing code would continue to work without modification. During this process, we discovered a subscription issue. It was an edge case where trying to subscribe to a channel more than once would be silently blocked, due to how Phoenix.js manages channel state. We identified the cause, advised the client on the right fix, and added a helper function that correctly handles callback transfer and channel recreation. We also made a handful of smaller contributions upstream to Phoenix.js itself during the course of the work. Finding the right approach to testing without direct platform access Testing a client tool when you can't run the full platform behind it requires a different approach. Since Supabase is open source and we were building a library, the only real way to verify our work was to build applications that actually use it. The client gave us the freedom to treat this like a hackathon: we were allowed to build something real, see what works, and learn from that. So, we built a shared terminal demo and an interactive Realtime explorer: a browser app where you can configure connections, set up channel bindings, and observe messages flowing in real time. These apps were the foundation for a mini test suite, with automated tests running against the actual library in the browser, giving the Supabase team a practical way to verify Realtime behavior. React Native integration The client wanted to make Realtime work reliably in React Native. We knew there were cases when a mobile app goes into the background and the WebSocket connection drops, and restoring it cleanly when the app comes back to the foreground wasn’t handled well in the previous implementation. That’s why we decided to extend the test playground to run as an Expo mobile application, reproduced and confirmed the reconnection behavior, and built a set of React Native hooks that tie Realtime channel connections to the mobile app lifecycle. With these hooks, connections are managed automatically depending on whether the app is active or backgrounded, closing a gap that had caused problems for React Native developers using Supabase Realtime. We also published an open-source scaffold repository demonstrating how to approach Realtime integration in React Native, which can serve as a starting point or reference for the community. Logflare: performance and reliability improvements Logflare is a log and metrics platform integrated into the client’s infrastructure. When running a self-hosted Supabase instance, Logflare handles log collection and routing across the stack. Overall, it's a big, distributed Elixir application built to process significant data volumes. We also joined the Logflare team as external contributors, bringing our Elixir expertise to collaborate on improving several areas of the platform. Integrating the BigQuery The platform was sending data to Google BigQuery using a legacy REST API that has since been deprecated. We migrated this to Google's newer Streaming API over gRPC. The new approach supports modern data formats and produces more compact log payloads, which means less outbound traffic on every event. And on a platform handling Logflare's volumes, that reduction translates directly into lower costs on Google Cloud, and it's also faster. Working on the ingestion pipeline's rule evaluation logic Logflare's ingestion API is where incoming log events are received and routed. Each event is evaluated against a set of user-configured rules to determine where it goes. Those rules can match on values and apply various conditions. With the original implementation, every rule for a given source was checked against every event, one by one. We rebuilt this as a tree-based data structure: rather than walking the entire rule list for every event, the system now traverses the tree and prunes branches that can't apply early in the process. Only the rules that are actually relevant to a given event get evaluated. This brings evaluation closer to logarithmic complexity, meaning the system checks far fewer rules per event compared to a sequential scan. Working on Adapters to enable data export from Logflare We implemented a set of adapters that allow exporting logs from Logflare to external observability services. This included integrations with Axiom and Last9, as well as an adapter for OTLP (OpenTelemetry Protocol), which serves as a universal standard for telemetry data exchange. Delivering this required refactoring parts of the existing adapter system to make it more consistent and extensible, ensuring new destinations could be added without increasing system complexity. These changes also laid the groundwork for the Supabase’s new Log Drains destinations, which route logs from the Supabase stack to third-party services. More recently, we extended the adapters with connection testing capabilities, allowing users to validate external integrations before enabling log streaming. ## Results Working on this project was truly rewarding as we had the freedom to share our expertise and suggest solutions that are best suited to the goals and needs of Supabase. That kind of relationship produces the best results: when a client trusts you as an expert rather than just a task executor, you can address problems at their root instead of relying on workarounds. Some of the project highlights include: Realtime.js successfully migrated to canonical Phoenix.js, eliminating the need to maintain a custom forkBrowser-based test playground built from scratchBigQuery integration modernized, reducing traffic costs and adopting current API standardsLogflare ingestion pipeline optimized with a tree-based rules engineCache reliability improved across Logflare's configuration layer