iris

News

> 🚀 **Iris v14 is on the way.** The next major version is the largest release in the project's history: the framework rebuilt on Go generics, an application builder the compiler checks, request helpers that validate for you, one central error map, thirty built-in middleware and a book that ships inside the repository. See [what is coming in Iris v14](#-what-is-coming-in-iris-v14) below. > > The version you are reading about here, **v12**, keeps working and keeps getting fixes. v14 arrives on a new import path, so nothing on your side breaks the day it lands. # Iris Web Framework العربية [](https://github.com/kataras/iris/tree/main/_examples) [](https://gitter.im/iris_go/community) [](https://iris-go.com/donate) ⚡ Iris is a fast, simple yet fully featured and very efficient web framework for Go. ✨ It provides a beautifully expressive and easy to use foundation for your next website or API. 🌟 Learn what [others say about Iris](https://www.iris-go.com/#review) and **[star](https://github.com/kataras/iris/stargazers)** this open-source project ```go package main import "github.com/kataras/iris/v12" func main() { app := iris.New() app.Use(iris.Compression) app.Get("/", func(ctx iris.Context) { ctx.HTML("Hello %s!", "World") }) app.Listen(":8080") } ``` As one [Go developer](https://twitter.com/dkuye/status/1532087942696554497) once said, **Iris got you covered all-round and standing strong over the years** ⭐ Some of the features Iris offers: * HTTP/2 (Push, even Embedded data) * Middleware (Accesslog, Basicauth, CORS, gRPC, Anti-Bot hCaptcha, JWT, MethodOverride, ModRevision, Monitor, PPROF, Ratelimit, Anti-Bot reCaptcha, Recovery, RequestID, Rewrite) * API Versioning * Model-View-Controller * Websockets * gRPC * Auto-HTTPS * Builtin support for ngrok to put your app on the internet, the fastest way * Unique Router with dynamic path as parameter with standard types like :uuid, :string, :int... and the ability to create your own * Compression * View Engines (HTML, Django, Handlebars, Pug/Jade and more) * Create your own File Server and host your own WebDAV server * Cache * Localization (i18n, sitemap) * Sessions * Rich Responses (HTML, Text, Markdown, XML, YAML, Binary, JSON, JSONP, Protocol Buffers, MessagePack, Content Negotiation, Streaming, Server-Sent Events and more) * Response Compression (gzip, deflate, brotli, snappy, s2) * Rich Requests (Bind URL Query, Headers, Form, Text, XML, YAML, Binary, JSON, Validation, Protocol Buffers, MessagePack and more) * Dependency Injection (MVC, Handlers, API Routers) * Testing Suite * And the most important... you get fast answers and support, from the first day until now ## 🚀 What is coming in Iris v14 Iris v14 is the largest release in the project's history. It rebuilds the framework on Go generics and changes how an application is put together: less wiring in `main`, shorter handlers, and one place for the decisions that used to be scattered across every route. None of it needs your attention today. v12 keeps working, keeps getting fixes, and v14 arrives with a migration guide that covers every renamed and removed API. ### The whole application in one compile-checked chain `iris.NewBuilder` wires CORS, compression, access logging, the health endpoint, the error map, your services and your API groups in a single expression. The compiler enforces the step order, so an application either builds correctly or does not build at all. ```go iris.NewBuilder(). Prefix("/api"). AllowOrigin("*"). Compression(true). LogRequests(true). Health(true, "production", "kataras"). Errors(errors.NewOptions(). MapErrors(errors.NotFound, catalog.ErrNotFound)). Services(catalog.NewRepository, catalog.NewService). API("/products", api.NewProductsAPI). Build(). Listen(":8080") ``` ### Handlers stop repeating themselves Decoding, validation and error rendering move out of the handler body. `rest.ReadJSON[T]` decodes the request, runs the type's `Validate() error` when it has one, and writes the 400 itself. The response helpers write the success status, or whatever your central map says that error should return. ```go func (api *ProductsAPI) create(ctx iris.Context) { input, ok := rest.ReadJSON[catalog.ProductInput](ctx) if !ok { return // 400 already written: malformed JSON or failed Validate. } id, err := api.svc.Create(ctx, input) rest.Created(ctx, id, err) // 201, or the centrally mapped error. } ``` `rest.OK`, `rest.NoContent`, `rest.Count` and `rest.Paginated` cover the rest of the shapes an API returns. ### Errors are declared once The new `rest/errors` package holds the mapping from your domain errors to HTTP responses. Clients get canonical, machine-readable payloads. Internal messages stay internal. Register a collector and every failure reaches your logger or your database from a single place. An error can render as JSON or as a view, depending on what the client asked for. ### Dependency injection everywhere, not only in MVC Constructors declare what they need and the container provides it: for handlers, for API groups, for controllers. A service that implements `Init(ctx context.Context) error` runs once inside `Build()`. Anything closeable is closed at shutdown. The `hero` package is gone, replaced by `dep` and `rest`, which do more in fewer lines. MVC controllers are built on generics. ### The packages are where you would expect them `sessions`, `cache`, `websocket`, `i18n`, `view` and `versioning` became middleware. `mvc` moved under `controller`, next to the new `fileserver`, `sitemap` and `apigraph` controllers. `apigraph` renders your route tree as an interactive D3 graph. Thirty middleware ship in the box, including new ones: `httpcost` (time, memory and CPU per request, for performance work or billing), `bodylimit`, `compress`, `counter`, `referrer`, `geolocation`, `ipaccess` and `servertiming`. View engine implementations moved to [iris-contrib/views](https://github.com/iris-contrib/views). ### Configuration is a partial literal `iris.Configuration` and the `With*` configurators are replaced by `iris.Options`. Set the fields you care about and the rest come from the defaults. `Bind` loads YAML from the `SERVER_CONFIG` environment variable, then from a file. ```go app := iris.New(iris.Options{Name: "myapp", LogLevel: "debug"}) ``` ### Names that say what they do Reading a request header and setting a response header no longer share a prefix that quietly flips meaning: `ctx.Header` reads the request, `ctx.SetHeader` and `ctx.ResponseHeader` work on the response. `Party` is now `Router`. `ctx.URLParam` is now `ctx.Query().Get`. Every rename is listed in the migration guide with its replacement, and most are one search and replace. ### Secure by default Session cookies ship with `Secure` and `SameSite=Lax`. The request body limit is enforced on every read path. Long-standing bugs went down with the rebuild, among them a rate limiter that recorded limits without ever enforcing them and a `Logout` call that could take the process with it. ### Documentation you can read start to finish v14 comes with a book of 23 chapters inside the repository, a getting started tutorial that builds a tested REST API in one document, a migration guide for v12 applications, and a live AI wiki generated from the source that answers questions about the codebase. ### What it means for your v12 code The import path becomes `github.com/kataras/iris/v14`, so v12 and v14 can sit side by side and nothing breaks on release day. Upgrade when it suits you. The migration guide covers the import path, the package moves, every removed API and its replacement, and the behavior changes, with ready commands for the mechanical parts. There is no public release date yet. Watch [releases](https://github.com/kataras/iris/releases) or follow [@iris_framework](https://twitter.com/iris_framework) to hear about it first. ## 👑 Supporters With your help, we can improve Open Source web development for everyone!