Universal Code Generation · v2.1

One spec.Eleven languages.Zero templates.

MetaEngine compiles OpenAPI, GraphQL, Protobuf and SQL into production-ready client code — without hand-written templates. Language-native idioms. Framework-correct. Instantly.

petstore.yamlAngular 1.3ms
@Injectable({ providedIn: 'root' })
export class PetService {
  private http = inject(HttpClient);
  private baseUrl = inject(BASE_URL);

  listPets = httpResource<Pet[]>(() =>
    `${this.baseUrl}/pets`
  );

  createPet(pet: NewPet): Observable<Pet> {
    return this.http.post<Pet>(
      `${this.baseUrl}/pets`, pet
    );
  }
}
01 · Architecture

Four sources. One intermediate representation. Eleven languages.

Every source format becomes the same typed graph. Everything after parsing is format-agnostic — which is why adding a new target or source doesn't force a rewrite of the other.

Sources
OpenAPI
REST · JSON Schema
GraphQL
SDL · operations
Protobuf
proto3 · services
SQL
DDL · schemas
Intermediate
IR
typed · resolved · language-agnostic
Targets
TypeScript
Python
Rust
Go
Java
C#
Swift
Kotlin
Scala
Groovy
PHP
02 · Pipeline

Compile, don't template.

Four stages — each reasoning about code the way a senior engineer on that stack would, not a string-interpolation pass.

01

Parse.

OpenAPI, GraphQL, Protobuf and SQL converge on one unified AST. Everything after this is format-agnostic.

02

IR.

Names, references, type relationships and nullability are resolved semantically — not as strings.

03

Transform.

Language-specific passes reshape the graph for each target: Angular signals, Python dataclasses, Go idioms.

04

Emit.

Output runs through the target's own formatter — Prettier, Black, gofmt, rustfmt. Deterministic and diff-friendly.

Official packages
3
@metaengine/openapi-angular, openapi-react and the MCP server on npm.
Target languages
11
Core emitters: TypeScript, Python, Rust, Go, Java, C#, Swift, Kotlin, Scala, Groovy, PHP.
Source specs
4
OpenAPI, GraphQL, Protobuf and SQL — every converter runs on the same IR.
Status
Online
Converters, playground, and MCP server are live.
04 · Principles

Generated code that reviews like hand-written code.

Three ground rules the engine holds to — so the output of MetaEngine stays legible, stable, and safe to regenerate.

Semantic.

The engine reasons about types, references and nullability — not character substitution. A Pet.id that is a UUID stays a UUID through every emitter.

Idiomatic.

Each target reads like code a senior engineer on that stack would ship: Angular inject(), React hooks, Python httpx, Go context, Rust Result<T, E>.

Regenerable.

Deterministic output runs through the language’s own formatter. Re-running generation in CI produces identical code. Nothing drifts.