iris README

The project's README from github.com/kataras/iris. As one markdown file: README.md.

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 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 العربية

build status view examples chat 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 and star this open-source project

Benchmarks: Jul 18, 2020 at 10:46am (UTC)

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 <strong>%s</strong>!", "World")
  })

  app.Listen(":8080")
}

As one Go developer once said, Iris got you covered all-round and standing strong over the years ⭐

Some of the features Iris offers:

🚀 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.

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.

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.

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.

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 or follow @iris_framework to hear about it first.

👑 Supporters

With your help, we can improve Open Source web development for everyone!

getsentry github lensesio thepunterbot h4rdc0m draFWM gf3 trading-peter AlbinoGeek basilarchia sumjoe simpleittools xiaozhuai Remydeme celsosz linxcoder jnelle TechMaster janwebdev altafino jakoubek alekperos day0ng hengestone thomasfr code-chimp CetinBasoz International Juanses <

iris (kataras/iris)

Searching Database…

25.6K ·GitHub
Iris
What is this?Iris is an open-source web framework for Go for building websites and APIs. It bills itself as fast, fully featured and easy to learn, with MVC, sessions, websockets and lots of built-in middleware.
Is it a framework or a library?A full web framework rather than a thin utility library: it owns routing, middleware, configuration and controllers, and ships its own dependency injection container and testing suite.
How do I add it to my Go project?Pull the module into your project with go get github.com/kataras/iris/v12@latest, import it and register routes. Upcoming v14 moves to github.com/kataras/iris/v14, so v12 and v14 can sit side by side.
Do I need anything besides Go to build and run an Iris app?Just the Go toolchain — an Iris app compiles to a single self-contained binary. To expose a dev server quickly there is builtin ngrok support for putting your app on the internet.
Is now a good time to adopt it?v12 is the current line and keeps getting fixes, but a major v14 is coming: new import path, renamed and removed APIs, and no public release date yet. A migration guide will cover the upgrade.
What do I get out of the box?A lot: HTTP/2, API versioning, websockets, gRPC, auto-HTTPS, caching, i18n, sessions, a router with typed path parameters (:uuid, :int), and middleware for CORS, JWT, basicauth, rate limiting, recovery and access logs.
What is changing in Iris v14?A rebuild on Go generics: an application builder the compiler checks (iris.NewBuilder), rest.ReadJSON[T] that decodes and validates requests, one central error map, DI everywhere, thirty middleware and a 23-chapter book in the repository.
Can it render HTML templates, or is it JSON APIs only?Both. View engines cover HTML, Django, Handlebars and Pug/Jade templates, while rich responses also include JSON, XML, YAML, Markdown, Protocol Buffers, MessagePack, streaming and server-sent events.
Do I write plain handler functions or MVC controllers?Either. You can register normal handler functions or use MVC controllers, and dependency injection works across both — handlers, API routers and controllers can all declare what they need.
What are similar projects?echo, beego, fiber, martini, sails, carno.js, angular.js, fastify
Which topics is it in?sessions, mvc, http2, dependency-injection, cache, https, templates, middleware, web-framework, i18n, websocket, http
Creator
kataras
Size
18 MB
Stars
25.6K
Updated
CommitJul 27Releasev12.2.11Apr 24
Age
10y
Commits · 90 Days