🎉 FURSY v0.1.0 - Production-Ready Release

[kolkov]

We're thrilled to announce the first production-ready release of FURSY - a next-generation HTTP router for Go 1.25+ that brings type-safe handlers, RFC 9457 error responses, and built-in OpenAPI generation to the Go ecosystem.

🔥 What Makes FURSY Different?

FURSY is the first Go router to combine:

• Type-Safe Generic Handlers - Box[Req, Res] with compile-time safety
• RFC 9457 Problem Details - Standardized error responses (native support)
• OpenAPI 3.1 Generation - Built-in API documentation
• Minimal Dependencies - Core routing uses stdlib only
• Production Performance - 256-326 ns/op, 1 alloc/op

🚀 Quick Example

package main

import (
    "github.com/coregx/fursy"
    "log"
    "net/http"
)

type CreateUserRequest struct {
    Name  string `json:"name" validate:"required"`
    Email string `json:"email" validate:"required,email"`
}

type UserResponse struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

func main() {
    router := fursy.New()

    // Type-safe handler with automatic binding & validation
    router.POST[CreateUserRequest, UserResponse]("/users",
        func(b *fursy.Box[CreateUserRequest, UserResponse]) error {
            user := createUser(b.ReqBody.Name, b.ReqBody.Email)
            return b.Created("/users/"+user.ID, UserResponse{
                ID:    user.ID,
                Name:  user.Name,
                Email: user.Email,
            })
        })

    // Simple handlers with convenience methods
    router.GET("/users", func(c *fursy.Context) error {
        return c.OK(getAllUsers())  // 200 OK
    })

    router.DELETE("/users/:id", func(c *fursy.Context) error {
        deleteUser(c.Param("id"))
        return c.NoContentSuccess()  // 204 No Content
    })

    log.Fatal(http.ListenAndServe(":8080", router))
}

✨ Key Features

🎯 Hybrid Response API

• Explicit methods for full control: JSON(code, data), String(code, text)
• Convenience methods for REST best practices: OK(data), Created(data), NoContentSuccess()
• Best of both worlds - flexibility meets developer experience

🛡️ Production-Ready Security

• JWT Authentication (94.2% coverage)
• Rate Limiting with token bucket (94.4% coverage)
• Security Headers - OWASP 2025 compliant (100% coverage)
• Circuit Breaker with auto-recovery (95.5% coverage)
• All with minimal external dependencies

📋 RFC 9457 Problem Details

// Returns standardized error responses
return c.Error(404, fursy.NotFound("User not found"))

// JSON output:
// {
//   "type": "https://fursy.coregx.dev/problems/not-found",
//   "title": "Not Found",
//   "status": 404,
//   "detail": "User not found"
// }

📚 Built-in OpenAPI 3.1

spec := router.OpenAPI(fursy.OpenAPIConfig{
    Title:   "My API",
    Version: "1.0.0",
})
// Complete OpenAPI spec generated from your routes!

📊 Performance

Benchmarked on Intel Core i7-1255U (12th Gen):

Static routes:       256 ns/op,  1 alloc/op  (~10.5M ops/s)
Parametric routes:   326 ns/op,  1 alloc/op  (~7.2M ops/s)
Wildcard routes:     539 ns/op,  1 alloc/op  (~7.8M ops/s)

Test Coverage: 91.7% (100+ test functions, 300+ test cases)

🎓 Design Philosophy

FURSY follows the philosophy of our sister project Relica:

1. Type Safety First - Leverage Go generics for compile-time guarantees
2. Minimal Dependencies - Core package uses stdlib only
3. Standards Compliance - RFC 9457, OpenAPI 3.1, RFC 9110
4. Performance Matters - Zero-allocation hot paths
5. Developer Experience - Intuitive API, clear error messages

🗺️ What's Next?

v0.1.0 is production-ready with complete routing, middleware, and security features.

Future releases (v0.2.0+) will add:

• Database middleware (PostgreSQL, MySQL, SQLite)
• Cache middleware (Redis, Memcached)
• Documentation website (fursy.coregx.dev)
• Migration guides from Gin, Echo, Chi

v1.0.0 LTS (Q3 2026) will provide long-term API stability guarantees after 6-12 months of production validation.

We're NOT rushing to v1.0 - API stability is a serious commitment.

📦 Installation

go get github.com/coregx/fursy

Requirements: Go 1.25+

📖 Documentation

• README - Overview and quick start
• Release Notes - Complete feature list
• API Documentation - Full API reference
• PERFORMANCE.md - Detailed benchmarks
• CONTRIBUTING.md - Development guide

💬 We Want Your Feedback!

This is our first public release, and we'd love to hear from you:

• 🐛 Found a bug? Open an issue
• 💡 Have a feature request? Start a discussion
• 🤝 Want to contribute? Check CONTRIBUTING.md
• ⭐ Like the project? Star the repo!

🙏 Credits

FURSY stands on the shoulders of giants:

• ozzo-routing - Middleware architecture inspiration
• httprouter - High-performance radix tree routing
• fiber - Performance benchmarks and optimization techniques
• FastAPI - Type hints + automatic OpenAPI generation

🚀 Try It Out!

# Create a new project
mkdir my-api && cd my-api
go mod init my-api
go get github.com/coregx/fursy

# Create main.go (see example above)
# Run
go run main.go

Welcome to FURSY! We're excited to see what you'll build with it. 🔥

---

Links:

• Repository: https://github.com/coregx/fursy
• Release: https://github.com/coregx/fursy/releases/tag/v0.1.0
• Documentation: https://pkg.go.dev/github.com/coregx/fursy
• Discussions: https://github.com/coregx/fursy/discussions
• Issues: https://github.com/coregx/fursy/issues