TL;DR:
New open source project - a unified toolchain for generating code from a single data model definition. It includes an IDL (Interface Definition Language), CLI and a VS Code extension.

More info at gluelang.dev

#Problem statement

message User {
  string id = 1;
  string email = 2;
  string name = 3;
}

1. Every codegen tool has its own set of configs, variations and inconsistencies, often within the same language ecosystem. If you have a polyglot codebase, or want to share types with another team or codebase, and they use a different language - there are at least two of these CLIs involved. If you use an OpenAPI spec and diverge from HTTP or the formats it supports natively - you need another tool to maintain a single source of truth. Maybe this problem can be solved or at least minimized with some Swiss-army-knife unified toolchain for OpenAPI, but from my experience it's almost never the case.
2. OpenAPI is great, but as its name implies it's meant and designed for APIs, and primarily REST APIs - for a web server where you want to model the endpoints, the schemas for the requests and responses this all makes sense, but what if you only care about the types?
   Then you sort of "abuse" OpenAPI solely for generating types (so your openapi.json relies mostly on the components section) and you now need to manage large JSONs with (IMO) a verbose syntax. This gets complicated if you want to model a binary protocol, custom protocol, etc.
3. More tools = increased supply chain attack surface. You may care about this more or less, depending on your circumstances.

https://xkcd.com/927

1. Simple, generic yet extensible IDL which abstracts itself from the presentation layer (like REST)
2. Human-friendly and LLM-friendly - should be well-structured, easy to maintain and have very sane defaults
3. Agnostic to languages/frameworks - generic to accompany the widest variety of usecases, but has "escape hatches" to allow for customization
4. Single CLI for generating code from this IDL
5. Ecosystem around this IDL to make working with it easy
6. UI (like SwaggerUI or Redoc) that makes it nice to share and explore the schemas and interfaces

/// Use triple slash for comments that should be included in generated code as docstrings
model Apartment {
  /// The apartment number, e.g. "1A"
  number: int
  // Use double slash for internal comments and not included in generated code
  residents: Person[]
}

model Person {
  name: string
  age: int
  residence_end_date?: string // Optional fields are denoted with a `?`

  is_employed: bool = false // Default values are supported
}

model Building {
  name: string
  apartments: Record<int, Apartment> // Complex types like maps, lists, etc. are supported

  address: Address

  // Nested models are supported
  model Address {
    street: string
    city: string
    country_code: string
    zipcode: string
  }
}

// Glue supports endpoints (like OpenAPI), which you can optionally define with sane defaults.
/// Get building information by the building ID
endpoint "GET /building/{building_id}" GetBuilding {
    responses: {
        200: Building
        4XX: ApiError
        5XX: ApiError
    }
}

model ApiError {
    code: Code
    message: string

    enum Code: "INVALID_REQUEST" | "NOT_FOUND" | "INTERNAL_ERROR"
}