Okay, here is the abstract and summary for the provided transcript about LiveView Native.

Abstract:

This presentation announces the official release of LiveView Native version 0.3, detailing its core philosophy and architecture after three years of development. LiveView Native enables developers to build native mobile and desktop applications using Elixir and Phoenix LiveView, rendering first-class native UI components (like SwiftUI or Jetpack Compose) driven by server-sent markup, explicitly distinguishing itself from WebView-based approaches. It functions conceptually like a browser, leveraging native UI frameworks, styling mechanisms analogous to CSS (using native modifiers via attributes and stylesheets), and standard web practices like cookie-based authentication. The talk highlights the benefits of targeting native platforms directly, showcasing support across the Apple ecosystem (including Vision Pro) with a real-world example (LAX Slack clone) and the LVN Go developer tool that simplifies iteration without needing Xcode. It addresses key topics like Android support status (in progress, using Jetpack Compose), plans for offline capabilities, the add-on system, and the underlying LiveView Native Core library built in Rust for shared client logic. The presentation concludes by offering resources like LiveBooks for getting started and promoting Dockyard's services for adoption and training.

LiveView Native 0.3 Release and Overview

• 0:00:25 - Official Release: LiveView Native version 0.3 is officially released and recommended for use after three years of development.
• 0:01:00 - Not a Web View, but a Browser: LiveView Native does not use WebViews. It acts conceptually like a browser by fetching markup from a server and rendering native UI components directly (e.g., SwiftUI VStack, HStack, Text). Key Takeaway: It aims for true native UI rendering driven by the server.
• 0:01:55 - Markup to Native Mapping: Demonstrates how a specific markup (using Swift UI elements as an example) directly translates 1-to-1 into native Swift UI structs (VStack, HStack), preserving the hierarchy. Key Takeaway: The server sends declarative UI instructions specific to the target native platform.
• 0:03:10 - Native Styling via Attributes: Styling is applied using native platform modifiers (e.g., Swift UI modifiers) specified within a style attribute, similar to inline CSS but using native framework syntax.
• 0:04:38 - Class-Based Styling & Stylesheets: Similar to CSS classes, you can use a class attribute with space-separated names. These classes are defined in Elixir-based stylesheets (.swiftui.ex files using a ~SHEET sigil) which get pre-compiled. The system scans the project (like Tailwind) to generate necessary styles. Key Takeaway: Offers a familiar class-based styling approach adapted for native modifiers.
• 0:06:45 - Browser Concepts Applied: Extends the browser analogy by mapping HTML -> Native Markup (Nix), CSS -> Modifiers, DOM -> View Tree, JS -> Native Code (Swift/Kotlin), and uses standard HTTP cookies for authentication. Key Takeaway: Leverages existing web/browser concepts where applicable for a smoother developer experience.
• 0:08:56 - Why Not Cross-Platform Frameworks (like Flutter)?: Avoids "build once, run anywhere" frameworks that often feel non-native. Aims to provide a first-class user experience by using the platform's specific UI frameworks (SwiftUI, Jetpack Compose, potentially WinUI3/MAUI).
• 0:10:11 - Broad Platform Support (via Native Frameworks): Using SwiftUI allows LiveView Native apps to compile for iPhone, iPad, Apple Watch, Apple TV, macOS, and Apple Vision Pro today. Key Takeaway: Targeting native frameworks provides wide reach within that ecosystem.
• 0:10:36 - Demo: Apple Vision Pro: Showcases a multiplayer augmented reality building game running on Apple Vision Pro, built with LiveView Native and Phoenix Presence.
• 0:11:33 - Future-Proofing & Leveraging Platform Updates: Easily supports new devices within an ecosystem (like a potential HomePod with screen) as long as they use the target framework (SwiftUI). Quickly adopts new OS features (iOS 18 support already in a branch). Key Takeaway: Reduces maintenance burden by relying on platform vendors (Apple, Google) for UI components and updates.
• 0:12:42 - Production Example: LAX: Confirms LiveView Native is used in production with LAX, a Slack clone built by Justin Schneck, available in the App Store.
• 0:14:03 - Performance Issue in 0.3: Acknowledges a rendering latency/lag when navigating between LiveViews (causing disconnects) in the current 0.3 release, visible in the LAX app.
• 0:14:42 - Performance Fix Incoming: A fix is in development (on main) to provide a smoother navigation experience by better handling in-flight navigation disconnects.
• 0:15:06 - Xcode Necessity: You might need Xcode for compiling custom add-ons or deploying to the App Store, but it's not required for initial development thanks to LVN Go.
• 0:15:51 - LVN Go Developer Tool: An App Store application (iOS, iPadOS, macOS) that acts as a LiveView Native client. It allows developers to connect to a LiveView Native server (via URL/IP/QR Code) and see changes instantly with live reload, bypassing the need for Xcode during development.
• 0:17:57 - LVN Go Features & Cookbook: LVN Go includes pre-baked add-ons (LiveForm, AVKit, Swift Charts, MapKit). It can be used with App Clips, demonstrated with the cookbook.livenative.dev example site which showcases various UI patterns and features (all open source).
• 0:18:35 - Offline Support Strategy: Currently no offline support. The planned approach involves compiling with Elixir Desktop/Kit locally and using CRDTs for data synchronization (potentially via PowerSync or similar tech) with local storage (SQLite). Key Takeaway: Offline is a recognized need with a potential technical path identified.
• 0:19:31 - Android Support Status: Under active development using Jetpack Compose. Held back due to initial focus on SwiftUI for stability/convention setting and challenges with Jetpack Compose's inconsistencies (sometimes dropping into imperative code). It relies on LiveView Native Core. Key Takeaway: Android support is coming but requires careful implementation and stabilization of the core library.
• 0:20:38 - LiveView Native Core: A shared library built in Rust, providing core functionalities (Phoenix Channels client, LiveView lifecycle, diffing, parsing, DOM management) via UniFFI bindings to native clients (SwiftUI, Jetpack). Key Takeaway: Aims to simplify building new clients and ensure consistency.
• 0:21:36 - Testing for Compatibility: Actively working on running the official Phoenix LiveView test suite (unit and end-to-end) against LiveView Native Core (compiled to Wasm) to ensure maximum compatibility and identify gaps.
• 0:22:33 - Getting Started Resources: Recommends using the provided LiveBooks (interactive documentation) in conjunction with the LVN Go app for learning and development.
• 0:23:15 - Best Practices & Hybrid Apps: Emphasizes using optimistic UI updates and assign_async to mitigate latency. Mentions that LiveView Native can be integrated into existing native applications (hybrid approach), not requiring a full rewrite.
• 0:24:31 - Call to Action & Services: Encourages contacting Dockyard for building applications (offering discounts for early adopters) or team training workshops.
• 0:25:00 - Final Demo Replay: Repeats the Vision Pro / iPad multiplayer demo highlighting real-time interaction via Phoenix Presence.