Software Engineer · Rust Library Design

Eddy Kamto

Software Engineer · Rust · TypeScript · Go

“I am currently working on a version of Ivo that is macro driven and the results are already very promising.”

Eddy is a software engineer working across TypeScript, Go and Rust, and the author of Ivo, an open-source event-driven schema validator for JavaScript and TypeScript applications. He is porting it to Rust. Translating a dynamic TypeScript API into Rust forces every question a library author can skip in JS: who owns the values, how errors are typed, and what can be checked before the code runs.

The first Rust version explored functional validation, per-field lifecycle hooks, and context options. Eddy is now pushing the design toward proc-macro generated code and stronger compile-time guarantees.

TypeScript

Language Ivo was first written in

Part of his backend stack

Rust

Language of the Ivo port and redesign

OSS

Author of Ivo, a schema validation library

The starting point

A dynamic validation model in a static language

In TypeScript, Ivo can attach arbitrary hooks and values to any field at runtime. Rust has no such escape hatch for free: flexible entity rules mean type erasure and runtime lookups, while compile-time guarantees mean generated code.

✓ Different rules per operation: create, update, delete
✓ Custom errors and context shared across hooks
✓ Flexibility traded against what the compiler can check

The outcome

A real Rust port with a next step

Eddy published the Rust port and shared a demo. The next iteration moves toward proc-macro generation, typed handlers, better encapsulation, and stronger compile-time validation.

✓ Public Rust branch and working demo
✓ Macro-driven redesign underway
✓ Performance and memory behavior measured in the demo

The journey

One clear path through the build

Step 011 / 5

Origin

Ivo starts as a TypeScript library: schema validation organized around user stories and events.

Step 022 / 5

Ivo in Rust

He ported Ivo, a user-story-focused event-driven schema validator for JavaScript and TypeScript applications.

Step 033 / 5

Lifecycle hooks

The Rust port explores per-field lifecycle hooks, context options, and a functional style for validating different entity models.

Step 044 / 5

Proc-macro pivot

The newer direction generates code and types per handler, with better encapsulation and compile-time validation goals.

Step 055 / 5

Current build

Eddy reports promising throughput and memory-stress results while continuing the macro-driven redesign.

Drag to explore · Select a milestone to read the full story

[ The idea ]

A TypeScript validation idea, rebuilt in Rust

Ivo is a user-story-focused, event-driven schema validator for JavaScript and TypeScript applications. Instead of describing a schema once, it validates per operation: what a field must look like on create is not what it must look like on update.

The Rust port lives in a dedicated rs branch next to the original TypeScript library, so both implementations of the same validation model can be compared side by side.

[ Design tension ]

Flexible entity rules versus compile-time guarantees

The current design uses per-field lifecycle hooks and context options to support different entity models and custom errors. Eddy is exploring how far proc macros can move validation and generated code toward compile time.

The functional API covers create, update, and delete flows, and the context can cache values during validation. HashMap storage and erased values remain an explicit, acknowledged tradeoff.

[ Macro redesign ]

Generated code is the next proof point

The newer Ivo version generates more of the handler code, assigns types automatically, and improves encapsulation. Eddy reports release-mode demo operations under 2ms and a much smaller build footprint than the earlier implementation.

The demo measures create, update, and delete operations, and the reported target-directory peak dropped from over 100GB to about 10GB. The proc-macro implementation is still evolving.