Universal Code Generation

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. Fast enough to iterate.

Open ConvertersOpen Playground
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.

03 · Featured converters

Six pairings your team can use today.

Every converter here runs the same IR pipeline. Source format on the left, target stack on the right — pick the pair that matches your repo.

OpenAPITypeScript
Angular services with httpResource, React hooks with TanStack Query, or framework-agnostic fetch.
Open converter
OpenAPIPython
httpx-based async clients with Pydantic v2 models. Fully typed, cleanly separated.
Open converter
OpenAPIC#
HttpClient clients and record DTOs — the way a Spring-for-Java veteran would write them in .NET.
Open converter
GraphQLKotlin
Operations become suspending Ktor calls; fragments collapse into kotlinx.serialization data classes.
Open converter
ProtobufGo
Idiomatic net/http clients plus context-aware services — no third-party stub generator required.
Open converter
SQLJava
DDL schemas become JPA-style records with relationships and nullability preserved.
Open converter
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.

Output runs through the language’s own formatter, so regenerating against the same spec and engine version yields the same bytes. Commit the generated code and CI re-runs land as no-op diffs; when the engine evolves, the diff surfaces the upgrade clearly.