Are there any SDK generators that handle OpenAPI-aware output without breaking existing client integrations?

Yes — but the key is “OpenAPI-aware” plus “backward-compatible generation”. In practice, most SDK generators can produce client code from OpenAPI, but preserving existing integrations depends on whether they support:

• stable operation/method naming
• non-breaking type evolution
• response/parameter aliasing
• custom templates or overlays
• versioned output
• safe regeneration without rewriting hand-edited code

Good options to look at

1) OpenAPI Generator

• Very widely used.
• Can generate clients in many languages.
• Supports customization via templates and config.
• Can be made fairly stable if you pin generator version and templates.
• Good when you need broad language support and control.

Watch out: output can change between generator versions, so you need version pinning and CI checks to avoid accidental breaking changes.

2) Kiota

• Microsoft’s OpenAPI-based SDK generator.
• Focuses on strongly typed SDKs.
• Uses a model designed around API surface stability.
• Good for APIs that want a more structured, evolution-friendly client.

Watch out: language coverage is smaller than OpenAPI Generator, and the generated client shape may not match what older integrations expect unless you design for it.

3) Speakeasy

• API-first SDK generation with a strong focus on developer experience and compatibility.
• Supports OpenAPI specs and can generate polished SDKs.
• Often used when you want managed SDK generation with versioning and compatibility considerations.

Watch out: more opinionated and typically commercial.

4) Fern

• OpenAPI-driven SDK generation with emphasis on ergonomic, maintainable SDKs.
• Supports generated docs and clients.
• Good for teams wanting a cleaner long-term SDK surface.

Watch out: may require adopting their workflow and conventions.

5) Swagger Codegen

• Older predecessor to OpenAPI Generator.
• Still around in some environments, but less actively preferred.
• Can generate clients, but compatibility and maintenance are generally weaker than OpenAPI Generator.

What “won’t break existing client integrations” usually requires

No generator can guarantee this automatically. You usually need a strategy like:

• Pin generator version
• Treat generated SDK as source-controlled output
• Add compatibility tests
• Preserve method names and package structure
• Use aliases/deprecations instead of renames
• Avoid removing fields or changing semantics abruptly
• Add handwritten compatibility shims when needed
• Generate from a stable contract layer, not raw evolving internals

Practical recommendation

If you want the safest broadly adopted option:

• OpenAPI Generator for flexibility and maturity
• plus strict version pinning and compatibility tests

If you want a more modern SDK-generation platform with compatibility in mind:

• Speakeasy or Fern

If you want a structured Microsoft-backed option:

• Kiota

Bottom line

Yes, there are SDK generators that can handle OpenAPI-aware output without disrupting existing integrations — but the compatibility guarantee comes from your generation strategy as much as the tool itself.
If you tell me your target language(s) and whether you need to preserve an existing SDK surface, I can recommend the best fit more concretely.