A few years ago, I encountered neovim and a new concept: APIs as first-class citizens.

As I used it more and more in my work, I became increasingly aware of its importance.

Exposing the software's state and operations through APIs greatly improves the debugging experience, provides extensibility, and makes it very convenient for other programs to call them.

On the other hand, centering on APIs can also improve program structure, because the entire program is written around a single context.

Currently, I usually use HTTP as the external interface because it allows for operations using curl and exposes these operations to the front end.

Previously, I used Axum as the HTTP server and utoipa to export the API to OpenAPI. Then, I used tools to convert the OpenAPI as TypeScript code for front-end.

However, I quickly encountered some problems. First, utoipa's documentation isn't generated during the build process; I need to run `cargo test` separately to generate the OpenAPI documentation. Second, utoipa's procedural macros are sometimes complex than the functions themselves. Finally, Axum's type system is overly complex, making every interface writing or modification a painful experience.

Furthermore, while OpenAPI to TypeScript tools are available, their quality is often inconsistent, and the generated code is rarely usable.

I'm hoping for a tool that generates Rust/OpenAPI/TypeScript code by writing something like a proto file. For Rust, ideally, it would generate a trait, so implementing the trait would automatically implement the HTTP interface. In other words, I'd like a tool like this:

```

interface API {

    @get

    void hello_world();

    
    @post

    string hello_world2();

};

```

I've carefully studied tools like gRPC/TypeSpec, but I'm not entirely satisfied.

Since I have prior experience writing parsers and code generation tools, I finally decided to create my own—[XIDL](https://github.com/xidl/xidl). I made the following improvements:

First, I generated the trait and OpenAPI documentation using `xidl-build`, thus resolving the inconsistency in OpenAPI generation time.

Second, I exposed the HTTP interface as an asynchronous trait, hiding its internal complexity within the generated codes. This eliminates the need for developers to struggle with Axum's complex types.

Furthermore, I strictly defined the interface behavior using RFCs, ensuring consistent presentation across different languages. Simultaneously, I used [behave](http://behave.readthedocs.io/en/stable/) and [hurl](http://hurl.dev/) to ensure interoperability among all generators.

Furthermore, I wrote a simple [LSP](https://github.com/xidl/idl-language-server) that allows real-time preview of the OpenAPI interface via scalars. This enables direct HTTP API calls within the browser.

Super Simple Sync with Durable State and TanStack DB

My best friend vouched for the developer who took my money

AI sell-off intensifies as investors ditch chip stocks

Draws fractals defined by iterated function systems (IFS) using the chaos game

Radio Image Framing Protocol (RIFP)

Twitter raving about one-shot games with Sol-5.6 and Opus 5

Insurtech Amsterdam Announces Third Edition of Its Magazine

Radio Image Framing Protocol over low-rate radio links

Google's Beyond Zero: Enterprise Security for the AI Era

We Built Our Knowledge Base

High energy prices force Playmobil to end production in Germany

Ask HN: Thoughts on AMD Ryzen AI MAX+ 395 for Local AI?

What Even Are Microservices?

Intel shows off Starfire, a new space grade chip

Cooveb Experience – Travel, Refined

Try GossipStack on iOS – a drop-in social SDK for any app

Nudists, peaceniks, freeloading travellers: the people keeping Esperanto alive

How to Download and Run Kimi K3 Open Weights

About the security content of macOS Tahoe 26.6

Show HN: Kiln – a fast, native batch image processor

Show HN: DiscountHub – AI-assisted search for deals and promo codes

How AI Can Locate Hidden Defence Labs and Military Installations Without Breach

Building Real-Time Analytics with Streaming Engines

Can We Hillclimb to Heaven?

Ask HN: Is there legal risk in AI memory?

Someone runs K3 on 80x 5090s, for 20 tok/s

Randomness in large language models: What researchers need to know (and report)

Git-for-Each-Ref

China starts production of home-grown immersion DUV chipmaking tools – source

Show HN: APIs as First-Class Citizen

Show HN: Raw Binary Program Analysis Tool