Universal Code Generation

One spec.Eleven languages.Zero templates.

MetaEngine compiles OpenAPI, GraphQL, Protobuf and SQL into typed client code — without hand-written templates. Target-language idioms. Framework integrations. Fast enough to iterate.

Open ConvertersOpen Playground
petstore.yamlAngularservices/pets.service.ts 3ms recorded 
import { BASE_URL } from '../injection-token';
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { Inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { BaseApiService } from './base-api.service';
import { Pet } from '../models/pet';
import { NewPet } from '../models/new-pet';

@Injectable()
export class PetsService extends BaseApiService {

  constructor(
    protected override readonly http: HttpClient,
    @Inject(BASE_URL) baseUrl: string
  ) {
    super(http, baseUrl);
  }

  public listPets(limit?: number): Observable<Array<Pet>> {
    const paramObj: Record<string, unknown> = {};
    if (typeof limit !== 'undefined') paramObj['limit'] = limit;
    return this.execute<Array<Pet>>('/pets', undefined, { method: 'get', params: this.createParams(paramObj) });
  }

  public createPet(body: NewPet): Observable<void> {
    return this.execute<void>('/pets', body);
  }

  public getPet(petId: string): Observable<Pet> {
    return this.execute<Pet>(`/pets/${petId}`, undefined, { method: 'get' });
  }
}
Open in converter
Playground

One model. 11 languages.

The playground's e-commerce model next to the code the hosted engine generated for it. Switch the language: the model stays, the code follows.

model · e-commerce preset
  • id: UUID
  • version: number
  • updatedAt: Date
  • title: string
  • description?: string
  • price: Money
  • status: ProductStatus
  • tags?: string[]
  • constructor(productId: UUID, quantity: number)
  • addedAt: Date
  • note?: string
  • amount: number
  • currency: string
  • value: string
  • id: Id
  • version: number
  • updatedAt: Date
  • items: T[]
  • cursor?: string
  • total: number
  • DRAFT = 0
  • ACTIVE = 1
  • ARCHIVED = 2
import { Versioned } from './versioned';
import { UUID } from './uuid';
import { Money } from './money';
import { ProductStatus } from './product-status.enum';

export class Product implements Versioned<UUID> {
  id!: UUID;
  version!: number;
  updatedAt!: Date;
  title!: string;
  price!: Money;
  status!: ProductStatus;
  description?: string;
  tags?: Array<string>;
}
Recorded engine output · TypeScriptEdit this model in the playground
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 and Signals, React hooks with TanStack Query, or framework-agnostic fetch.
Open converter
OpenAPIPython
Async httpx clients paired with Pydantic v2 models. Fully typed, cleanly separated.
Open converter
OpenAPIJava Spring
RestClient services with Bean Validation, NON_NULL serialization, and configurable base-URL properties.
Open converter
GraphQLReact
TanStack Query hooks with discriminated-union types, named fragments, and generated query keys.
Open converter
ProtobufC#
HttpClient gRPC-Connect services with sealed record DTOs and Connect-RPC streaming helpers.
Open converter
SQLTypeScript
DDL schemas become interfaces or classes with foreign-key navigation properties and precision-safe decimals.
Open converter
Target languages
11
TypeScript, Python, Rust, Go, Java, C#, Swift, Kotlin, Scala, Groovy, PHP. Nine ship HTTP-client targets; all eleven ship SQL emitters.
Source specs
4
OpenAPI 3.0 + 3.1, GraphQL SDL, Protobuf proto3, and SQL DDL — every converter runs on the same IR.
Specs in corpus
287
228 OpenAPI + 42 Protobuf + 10 SQL + 7 GraphQL — Microsoft Graph, Stripe, Kubernetes and more compiled on every merge.
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.