@lpil raised an important point: Dream's router isn't type safe. Path parameters aren't encoded in types.

Change /users/:id to /users/:user_id and your handler fails at runtime, not compile time.

He's right.

We're trying to understand whether compile-time safety is worth redesigning the router API, and what approaches might be possible in Gleam.

Performance is solved

We've moved from linear search O(n routes) to a radix trie O(path depth). That part's done (PR coming today).

Benchmark results from testing radix trie router vs linear router:

• 100 Routes, First Route: 241x faster (11ms vs 2,748ms)
• 100 Routes, Middle Route: 122x faster (11ms vs 1,456ms)
• 100 Routes, Last Route: 2.48x faster (13ms vs 33ms)
• 500 Routes, Last Route: 2.23x faster (6ms vs 15ms)
• 1000 Routes, Last Route: 1.85x faster (1.6ms vs 3ms)
• 500 Routes, Not Found: 1,353x faster (8ms vs 11,047ms)

Type safety is the question

The problem:

router
|> route(
  method: Get, 
  path: "/users/:user_id/posts/:post_id", 
  controller: show_post,
  middleware: []
)

fn show_post(
  request: Request, 
  _context: AppContext, 
  _services: Services
) -> Response {
  // If you change path params, no compile error:
  case require_int(request, "id") {  // Wrong param name - runtime error
    Ok(id) -> // ...
    Error(error) -> // ...
  }
}

Path and controller aren't connected. Compiler can't help.

Type-safe routing would mean:

• Compile-time verification: wrong parameter name = type error
• Refactoring safety: change route path, compiler catches broken controllers
• More complex type signatures
• Potentially harder error messages
• Less dynamic (routes known at compile time)

Current runtime approach:

• Simple API: route(method:, path:, controller:, middleware:)
• Clean error messages
• Parameters checked at runtime with require_int(request, "id")
• Easy to add routes dynamically
• Fails at runtime if parameter names mismatch

Questions

1. Real-world experience

In frameworks you've used (Phoenix, Rails, Express, Django, etc.), do path parameter mismatches make it to production? Or do tests catch them first?

2. What would you trade for safety?

Would you accept:

• More verbose route definitions?
• More complex type signatures?
• Harder compiler errors?
• Less dynamic routing?

3. Examples from other ecosystems

What type-safe routing have you used? What felt good? What was painful?

4. What's possible in Gleam?

Without macros or build-time codegen, what approaches could work? Are there patterns we're missing?

Share your thoughts

Your experience helps us understand whether this is worth the engineering cost, and what solutions might be possible.