What do we have in general? How do we interact with Apps? Let’s start from the tip of the iceberg.

Cross-platform complexity | Platform Fragmentation

No unified way to develop against all Devices

Devices

1. Mobile
   • iOS
   • Android
2. PC
   • Linux
   • Arch, Ubuntu, Fedora, Debian ecosystems
   • X11 vs Wayland display servers
   • i3, dwm, KDE, GNOME desktop environments
   • macOS
   • Windows
3. TVs
   • Smart TV platforms (webOS, Tizen, tvOS)

What solutions do we currently have?

Current Solutions (2026)

1. Flutter (46% market share)

   • Support for 6 platforms, Web limited to Chromium | 4.5/5
   • Weaknesses: Non-native feel by default, larger binaries, plugin quality variance, weaker SEO/accessibility story on web, and edge platform integrations still requiring native code.

2. React Native (JavaScript/TypeScript)

   • Support for 4 platforms, Web/Desktop out-of-tree | 4/5
   • Weaknesses: Platform-specific code is often still needed, dependency/version breakage can be painful, upgrades can be expensive, and desktop/web remain secondary compared to mobile.

3. Kotlin Multiplatform (KMP) (Kotlin)

   • Support for 6 platforms, Web in beta | 4/5
   • Weaknesses: Shared UI is not default, iOS interop and tooling can be complex, multi-target build setup is heavy, and web target maturity still lags.

4. .NET MAUI (C#)

   • Support for 4 platforms, none in beta | 3.5/5
   • Weaknesses: Slower iteration outside Microsoft-centric teams, smaller cross-platform community than JS ecosystems, and weaker Linux/web story.

5. Ionic (JavaScript)

   • Support for 3 platforms, none in beta | 3/5
   • Weaknesses: WebView performance ceiling, less native UX fidelity, and plugin dependency risk for deeper device integrations.

6. Uno Platform (C#)

   • Support for 6 platforms, none in beta | 4/5
   • Weaknesses: Smaller ecosystem, enterprise-leaning learning curve, and platform-specific edge behavior still requiring tuning.

7. Electron (JavaScript/Node.js)

   • Support for 3 platforms, none in beta | 4/5
   • Weaknesses: Large bundle size, high idle RAM/CPU usage, slower startup on low-end devices, and higher attack surface if hardening is weak.

8. Tauri (Rust + Web Frontend)

   • Support for 5 platforms, iOS/Android in v2 | 4/5
   • Weaknesses: Steeper Rust learning curve, younger plugin ecosystem, more native complexity for advanced features, and mobile still newer than desktop.

9. Electrobun (TypeScript + Bun Runtime)

   • Support for 3 platforms, none in beta, v1 stable (Feb 2026) | 3.5/5
   • Weaknesses: Young ecosystem, fewer production-proven patterns/tools, smaller community, and Linux support scope still narrower than established alternatives.

Unfortunately, it is still not as nice and easy as we want.

All of them follow the same pattern, each framework doesn’t cover edge-cases, so it can’t be the go-to tool.

What are the alternatives? Let’s go a bit deeper.

My requirements are:

1. TypeScript, one of the most popular languages out there, easy to use and understand.
2. Mature tooling — “current meta.”

Phones

• React Native for most TypeScript teams that want one codebase and fast hiring.
• Flutter for teams prioritizing UI consistency/performance and full visual control.
• Kotlin Multiplatform for teams that want shared business logic but still keep native UI on each platform.
• SwiftUI (iOS) + Jetpack Compose (Android) for maximum native quality and deepest platform integration.

My choice is React Native + Expo.

PC

• Electron for maximum maturity/ecosystem and fastest hiring with web skills.
• Tauri v2 for smaller binaries/lower RAM and stronger security posture.
• Flutter Desktop for custom UI-heavy desktop products across all 3 OSes.
• Qt / Avalonia when you want non-web-native desktop architecture.

My choice is Electron — TypeScript again, interesting.

TVs

• React-native-tvos
• Kotlin Jetpack Compose for TV

Web

I hope we don’t forget that browser compatibility issues still exist, right?

• Next.js — King.
• Astro
• SvelteKit

TypeScript Ecosystem (Short)

• Typechecking: tsc --noEmit (stable default) or tsgo (beta, watch closely).
• Linting + Formatting: Biome.
• Unit/Integration tests: Vitest + Testing Library.
• E2E: Playwright (Chromium + Firefox + WebKit).
• API tests/mocks: Supertest + MSW.
• Runtime validation: Zod (or Valibot).
• Package manager: pnpm.
• Build: Vite (apps), tsup (libs).
• CI baseline: typecheck + biome + tests + build.

With TypeScript and AI, you are able to do practically almost anything… Anything except what?

TypeScript is excellent for product/web/backend/CLI speed, but not the best choice for kernel-level, embedded, or maximum-performance native systems.

• Python for science.
• Rust will cover the rest.
• C++ for game development.

Okay, we now have the language and ecosystem around it. Pick typescript to build anything.