We're heavily considering just having a website next year with a mobile app using webview, and then native code for the native notifications, GPS and healthkit / health connect.

I feel like AI is changing the equation, its nearly better to write your business UI 3 times one for each platform.

React Native grew a lot this year and a lot of things got or will be improved and copied from Lynx or Valid:

- 3 modes of compilation (AOT, JIT) from Valdi will be in static hermes (RN) in coming months.

- native binding generation -> RN already have such official generator and also nitro/nitrogen, they also working on Node-API

- executing animation and JS code in different thread (Lynx.js) -> worklet library in RN from swmansion

- tailwindcss support (Lynx) -> uniwind in RN land.

I think Lynx.js maybe have better shot at React Native since they want to support other frameworks instead of only React.

As a solo-dev, I realize well that this project isn't for me. This could be a great tool for experienced folks who know what they are doing. I will stick to Tauri and React Native, it does 80% of what I care about with 20% of the effort. Or until someone builds a nice wrapper around this to make it easy to use (and also add targets for x86_64/aarch64 builds).

How hard could it be?

  // Import the StatefulComponent
  import { StatefulComponent } from 'valdi_core/src/Component';
  
  // ViewModel + State interfaces for component
  export interface TimerViewModel { loop: number }
  interface TimerState { elapsed: number }
  
  // Component class
  export class Timer extends StatefulComponent<TimerViewModel, TimerState> {
    // Initialize the state
    state = { elapsed: 0 };
    // When creating the component, start a periodic logic
    private interval?: number;
  
    // Initialize the setInterval that will update state once a second incrementing
    // the `elapsed` state value.
    onCreate() {
      this.interval = setInterval(() => {
        // Increment the state to trigger a re-render periodically
        const elapsed = this.state.elapsed;
        const loop = this.viewModel.loop;
        this.setState({ elapsed: (elapsed + 1) % loop });
      }, 1000);
    }
  
    // When component is removed, make sure to cleanup interval logic
    onDestroy() {
      if (this.interval) clearInterval(this.interval);
    }
  
    // Render visuals will depend both on the state and the view model
    onRender() {
      <view padding={30} backgroundColor='lightblue'>
        <label value={`Time Elapsed: ${this.state.elapsed} seconds`} />;
        <label value={`Time Looping every: ${this.viewModel.loop} seconds`} />;
      </view>;
    }
  }

Concerning that there's no mention of Swift there. Or SwiftUI.

I’ll take it

Color me yellow.

Seriously, if there’s an app that sticks in my head for being noticeably laggy, you couldn’t pick a better example than Snapchat.

I presume this is a Text UI. How does it compares with ncurses and termcap ? /s