Crossa

Build once. Execute natively. Ship everywhere.

Crossa is a compiler-powered native runtime platform that turns shared .cra definitions into high-performance Android and iOS APIs backed by a common C++ runtime.

---

What is Crossa?

Mobile applications often implement the same backend layer twice:

Backend
   │
   ├── Android → DTOs, networking, parsing, errors
   └── iOS     → Models, networking, parsing, errors

Crossa replaces that duplication with a shared compiler and native runtime.

.cra Source
     │
     ▼
Crossa Compiler
     │
     ▼
Typed Crossa IR
     │
     ▼
C++ Native Runtime
     │
 ┌───┴────┐
 ▼        ▼
Kotlin   Swift
 │        │
 ▼        ▼
Android  iOS

The expensive work — networking, serialization, parsing, scheduling, memory ownership, and native models — stays in C++.

Android and iOS receive clean generated APIs.

---

Write Once

model User(
    id: Int,
    name: String
)

@AsyncAfter
fun getUser(id: Int): User {
    re CrossaRequest {
        path: "/v1/users/#id",
        method: GET
    }
}

Crossa compiles this into a native request plan:

Android / iOS
      │
      ▼
Generated API
      │
      ▼
Crossa C++ Runtime
      │
      ├── Request encoding
      ├── Networking
      ├── Response buffering
      ├── Native parsing
      ├── Native models
      └── Error / async state
      │
      ▼
Success(User)
Failed(CrossaError)
Cancelled

No separate Retrofit, Ktor, or URLSession implementation is generated.

---

Why Crossa?

Crossa is designed around a few core principles:

• C++ owns the hot path
• One shared execution model
• Native request and response processing
• Thin Kotlin and Swift bindings
• Fewer allocations and memory copies
• Fewer JNI / native boundary crossings
• Compile-time specialization over runtime reflection
• Deterministic generated APIs
• Native-backed models and collections
• Shared behavior across Android and iOS

---

Compiler Pipeline

.cra
 │
 ▼
Lexer
 │
 ▼
Parser
 │
 ▼
AST
 │
 ▼
Semantic Analysis
 │
 ▼
Typed IR
 │
 ▼
Optimization + Linking
 │
 ├───────────────┐
 ▼               ▼
Native Runtime   Generated APIs
                 │
            ┌────┴────┐
            ▼         ▼
          Kotlin     Swift

.cra is parsed once by the canonical C++ frontend.

Kotlin and Swift never implement their own Crossa parser or runtime semantics.

---

Android & iOS

	Android	iOS
API	Kotlin	Swift
Core	C++	C++
Distribution	AAR	XCFramework
Networking	Native	Native
Parsing	Native	Native
Scheduling	Native	Native
Platform layer	Thin binding	Thin binding

---

More Than Networking

Networking is the first production Crossa module, but the runtime is designed as a larger native platform.

                  Crossa Runtime
                        │
        ┌───────────────┼───────────────┐
        ▼               ▼               ▼
   Networking       Database        Realtime
                                    │
                              ┌─────┴─────┐
                              ▼           ▼
                         WebSocket      Sockets

Future runtime capabilities can include:

Database · WebSocket · Raw Sockets · Binary Protocols · Streaming · Cache · Files · Compression · Crypto · Telemetry

All built on the same compiler, runtime core, scheduler, memory model, and native ABI.

---

What Crossa Is Not

Crossa is not:

• a Kotlin Multiplatform replacement
• a UI framework
• a general-purpose programming language
• a Retrofit or Ktor clone
• an OkHttp or URLSession replacement implemented twice
• a generic JSON library

Crossa is a compiler-powered native runtime platform with generated platform APIs.

---

One compiler. One runtime. Native everywhere.

Crossa