High-performance logic. Shared at the byte level.
Write your app's logic once in TypeScript. Run it natively with zero-copy binary buffers. No JSON overhead. No compromises.
How it works
One source of truth. Binary performance.
Declare interfaces for your logic and state. Codegen creates native models automatically.
// playground.spec.ts
export interface PlaygroundState {
count: number
activity: string
}
export interface PlaygroundSpec {
increment(step: number): Promise<PlaygroundState>
processBuffer(buffer: ArrayBuffer): Promise<ArrayBuffer>
}Logic runs in JS. Move data via YolkBin or raw ArrayBuffers with zero intermediate copies.
// index.ts (Business Logic)
async function increment(step: number): Promise<State> {
count += step
return state() // SSOT: JS pushes new state to Native
}
async function processBuffer(buffer: ArrayBuffer) {
const view = new Uint8Array(buffer)
// Zero-copy byte manipulation
view[0] = 255 - view[0]
return buffer
}Native ViewModels are reactive to the JS heap. UI updates automatically when state mutates.
// Swift Implementation
actor AppPlaygroundModule: PlaygroundModule {
// Logic is in TS, UI is reactive to State struct
func increment(step: Double) async throws -> PlaygroundState {
// ... bridge handles the rest
}
func processBuffer(buffer: Data) async throws -> Data {
// Shared memory pointer access
return buffer
}
}Architected for Performance
Bridging the gap between the flexibility of JS and the power of Native.
Buffer-Only Bridge
JSON is eliminated. All data crosses the bridge as raw binary buffers using the high-performance YolkBin protocol.
Zero-Copy Memory
Direct shared-memory access between JS and Native. Perfect for media-heavy or real-time data processing.
Reactive SSOT
JavaScript owns the application state. Native is a reactive view, receiving binary updates via a subscription model.
End-to-End Typing
Unified codegen for logic proxies, native protocols, and state models. Mismatches are caught at compile time.
Polyglot Runtime
Production-ready support for JavaScriptCore (Apple) and QuickJS (Android), with a unified binary interface.
Async-First
Naturally bridges Swift async/await and Kotlin coroutines to standard TypeScript Promises.
Trusted by industry leaders
Completely real quotes from completely real people.
“I have rewritten this in Rust. It is now 0.3ms faster and nobody on my team understands it. Ship it.”
“I asked our 10x engineer to evaluate Yolk. He said it works on his machine. We have been unable to reach him since.”
“Noch ein verdammtes, bescheuertes JS-Framework. Ich werde euch alle abfackeln, ihr degeneriertes Pack!”
“Look, we tried Excel macros, okay? A total disaster. A catastrophe. They kept crashing all the time, very weak, very sad. But this framework? It’s huge. We built a beautiful wall between the business logic and the UI. The greatest technological wall in history, maybe of all time. The logic is very smart, a very high IQ, believe me. Nobody separates things better than us, it’s incredible.”
“I told the board that a single drop of TypeScript could detect any bug in the entire application. They believed me. We raised four hundred million dollars. It turns out Yolk actually does what I lied about. I am writing this from a minimum-security facility where I have finally achieved the 'purity' I always talked about. 10/10 would defraud again.”
“I have become death, the destroyer of legacy codebases. I thought we were just building a type-safe bridge, but the chain reaction of Promises was uncontrollable. The entire production environment vanished in a flash of amber-colored light. My conscience is clear: the implementation was elegant, and the fallout was minimal.”