鉄
Tetsu means iron.
Not a metaphor for speed or elegance — the plain material. Iron does what it looks like it does: you can see where it is joined, and it holds. That is what the framework tries to be.
No magic. Just iron.
The oni and the iron club
An old Japanese saying goes 鬼に金棒 — oni ni kanabō, “an iron club for the oni”. The oni is already the strongest creature in the story; give it an iron club and nothing stands in its way. It is said of someone capable who has just been handed the right tool.
In the mark, the oni is the developer, who already knows the domain, the data and the users. Tetsu is the club: plain iron that adds weight to every blow and stays out of the way of the hand.
- Red is the colour of the aka-oni, the red oni of Japanese folklore.
- The narrowed eyes watch. The compiler catches what would break before it runs.
- No mouth. The framework does not talk: no hidden behaviour, no conventions to guess.
- The club is iron, with rivets you can count. Every part is visible, and every joint is where you put it.
What you write is what runs
Open any route and what happens to its request is written there: the path, the schemas, the hooks by slot, the handler. What a group or the whole application adds is written where the application is wired, and every instance is built there by hand. There is no registry, no file scanning and no reflection. What you read is the whole program.
The types follow the same rule. A field is on the context exactly when it exists at that point of the request — the body after it was validated, the user after the hook that found them — and the compiler checks the order of hooks, what each needs and what each adds. A type that says something the program does not do is a bug, whichever side it is on.
What it will not do, and why
No decorators
A decorator cannot put an inferred type into a method's signature, so every handler would be annotated by hand — and the metadata it writes is a second program the compiler cannot read.
No container
Without runtime reflection, dependency injection is tokens and ceremony. One file that builds everything and hands it over is shorter, and a reader can follow it.
No router of its own
Bun already matches paths natively. A second matcher would be a second opinion on which route a request belongs to, and the two would one day disagree.
No plugins
A package is a hook, a controller or a function, used like your own code. Registration at runtime would make what runs for a route something to look up instead of something to read.
No middleware chain
Around next(), when a function runs is a property of the call stack. In a fixed slot it is a name, and the compiler can check the order.
No dependencies
The core depends on nothing. Validation is Standard Schema — an interface, not a package — so the schema library is yours.
What it borrows
Tetsu is not a new paradigm. It recombines ideas that proved themselves elsewhere: a request lifecycle with named stages, as in Elysia, without the method chain; hooks in fixed places, as in Fastify, with their types inferred; controllers and explicit composition, as in Nest, without decorators or a container. The value is in the combination — and in holding each piece to the same rule. The comparison says what it costs and when another framework fits better.
Open source
Tetsu is MIT-licensed and built in the open on GitHub. Questions, bugs and ideas go to the issue tracker; anything else to hello@tetsujs.com.