Digital identity: an ISO/IEC 39794-5 core in Eskiu

The setup

The company makes a web SDK for biometric capture during customer onboarding: a face capture with a liveness check, and the capture of official identity documents and passports. The SDK runs in the user's browser. Images and measurements stay on the device; nothing is sent to a server for processing.

Its output follows ISO/IEC 39794-5, the standard for exchanging face image data. Producing it takes more than saving a photo: the SDK builds the record and its JSON and XML forms, encodes it in ASN.1 and wraps it in a CBEFF block, measures the image's quality and lighting, extracts the face geometry and eye openness from the landmarks, checks the result against configurable profiles, and writes a validation report. All of this was TypeScript, and the native SDKs for Android and iOS would have needed it again in Kotlin and Swift.

Why Eskiu fit

• One source for the web and the phone. Eskiu compiles the same files to WebAssembly through emscripten and to static libraries with a C ABI for aarch64-linux-android and arm64-apple-ios, so the record a browser produces and the record a native app produces come from the same code.
• No runtime to carry. There is no garbage collector or virtual machine in the WebAssembly module, and the native libraries are plain objects for the platform's linker.
• Buffers in, buffers out. The core takes images and requests as byte buffers and returns its results the same way. A JPEG is not expanded into an array of numbers to cross into the module, and the per-frame checks take a few numbers, not the 478-point face mesh.
• Memory you can bound. Every result belongs to the core and is released exactly once, and the limits are explicit: a maximum module memory, a maximum image and a maximum request size, each rejected with an error when exceeded.

What moved into Eskiu

The core is about 2,500 lines of Eskiu in 18 files, split by responsibility. TypeScript keeps the public API and its types and becomes an adapter for what belongs to the browser: the camera, Canvas and pixel reads, clocks, the platform's XML parser, Web Crypto, caching and workers. The quality worker loads the same core and the same profiles as the main thread. The WebAssembly module is embedded in a hashed JavaScript chunk, so integrators deploy the SDK exactly as before.

How it was checked

The migration kept the existing behavior where it was right and the existing bytes where they were defined: records match the golden samples of the previous encoder, and the image measurements match the previous TypeScript implementation on deterministic pixel fixtures. 210 tests cover the record, the encodings, the worker, the final capture checks and the eye measurements, another 81 load every bundle the SDK ships, and the native build is exercised through its C ABI with no browser involved. Reformatting the Eskiu sources with eskiuc fmt leaves the compiled object identical byte for byte, which the team uses to keep style changes from hiding behavior changes.

The same sources cross-compile to ARM64 objects for Android and iOS. Linking them into the native apps is the next step of the integration.

The numbers

Starting the WebAssembly module takes 2 ms, and the memory it keeps reserved after a full analysis went from 52.9 MiB to 23.1 MiB, because the lighting pass no longer stores a double per pixel and recomputes it instead. These are synthetic measurements on an Apple Silicon machine under Node, including copying the pixels in and reading the result out; measurements on entry-level phones are still to come.

Identity checks are a domain where a record has to be the same wherever it is produced. With the logic written once in Eskiu, the browser and the native apps share it instead of keeping three implementations in step.