DEV Community

Cover image for [Typia] executable demo site of 20,000x faster validator (serializer)
Jeongho Nam
Jeongho Nam

Posted on

[Typia] executable demo site of 20,000x faster validator (serializer)


I've published an executable playground website of typia to demonstrate how typia is easier than other runtime validation (serialization) libraries, and describe what the AoT (Ahead of Compilation) is for TypeScript users.

Just visit the playground website, and click the "execute" button. Then you may understand what I mean.

Playground website of typia

export function is<T>(input: unknown): input is T; // returns boolean
export function assert<T>(input: unknown): T; // throws TypeGuardError
export function assertGuard<T>(input: unknown): asserts input is T;
export function validate<T>(input: unknown): IValidation<T>; // detailed

export namespace json {
  export function application<T>(): IJsonApplication; // JSON schema
  export function assertParse<T>(input: string): T; // type safe parser
  export function assertStringify<T>(input: T): string; // safe and faster

export namespace protobuf {
  export function message<T>(): string; // Protocol Buffer message
  export function assertDecode<T>(buffer: Uint8Array): T; // safe decoder
  export function assertEncode<T>(input: T): Uint8Array; // safe encoder

export function random<T>(g?: Partial<IRandomGenerator>): T;
Enter fullscreen mode Exit fullscreen mode


Story of typia.

typia is a transformer library supporting below features:

  • Super-fast Runtime Validators
  • Enhanced JSON functions
  • Protocol Buffer encoder and decoder
  • Random data generator

Also, typia does not require any extra schema definition like ajv or class-validator, but needs only the pure TypeScript type. Furthermore, its runtime validation is maximum 20,000x faster than class-validator, and JSON serialization is 200x faster than class-transformer.

All the secrets of typia (ability to understand the pure TypeScript type, and super-fast performance) are based on the AoT (Ahead of Time) compilation. typia analyzes your TypeScript codes and types in the compliation level, and writes optimal validation and serialization code for each type.



I made it for demonstration.

By the way, is my above explanation easy to understand?

I'd written some articles introducing typia on here, but more than half of the readers only understood that as "Wow, typia is super fast." I'd hoped to emphasize the "AoT compilation" concept and "easiness" as well as "super-fast", but I'd failed to appeal them cleary.

This is the reason why I've published the playground website, even including the TypeScript compiler, bundler and exector which can run on the web browser.

Visit the website, and write any TpeScript source code what you want. Then, you may understand how typia generates optimal validation and serialization code for your pure TypeScript type through the AoT compilation.

If you click the "execute" button of the right side, playground website will compile your TypeScript code, and run it on your browser. So that you can realize that typia is not a fake library, but the real convenient one.

Playground website of typia


Stable than any others.

I've shown that typia is super-fast and even easier to use through above chapters.

By the way, from the perspective of a runtime validation and serialization library, there is one thing that is much more important than ease or performance, and that is stability. No matter how fast and easy a library is, if it has poor stability and frequent bugs, it is a library of no value.

Furthermore, as typia guides users to utilize the pure TypeScript type, typia have to support every TypeScript types (In contrary, other libraries do not need to do it because they need extra schema definition). In such reason, I've concentrated on the test program development, because I had to.

Now, LOC of typia test program is about 250K. If includes the generated files, it overs 5M LOC. With long time efforts of test program developments, I can say with confident, "typia is the most stable library".

  • Line of Codes
    • main program: 34,516
    • test program: 246,229
    • test program (generated): 5,013,547
Components typia TypeBox ajv io-ts zod C.V.
Easy to use
Object (simple)
Object (hierarchical)
Object (recursive)
Object (union, implicit)
Object (union, explicit)
Object (additional tags)
Object (template literal types)
Object (dynamic properties)
Array (rest tuple)
Array (hierarchical)
Array (recursive)
Array (recursive, union)
Array (R+U, implicit)
Array (repeated)
Array (repeated, union)
Ultimate Union Type

Top comments (0)