iris

The fastest HTTP/2 Go Web Framework. New, modern and easy to learn. Fast development with Code you control. Unbeatable cost-performance ratio :rocket:

25,556

2,426

25,556

150

View on GitHub

Top Related Projects

gin

89,059

Gin is a high-performance HTTP web framework written in Go. It provides a Martini-like API but with significantly better performance—up to 40 times faster—thanks to httprouter. Gin is designed for building REST APIs, web applications, and microservices.

echo

32,778

High performance, minimalist Go web framework

fiber

40,230

⚡️ Express inspired web framework written in Go

mux

21,833

Package gorilla/mux is a powerful HTTP router and URL matcher for building Go web servers with 🦍

httprouter

17,135

A high performance HTTP request router that scales well

fasthttp

23,488

Fast HTTP package for Go. Tuned for high performance. Zero memory allocations in hot paths. Up to 10x faster than net/http

Quick Overview

Iris is a fast, simple, and efficient web framework for Go. It provides a robust set of features for building web applications and APIs, with a focus on high performance and ease of use. Iris is designed to be expressive and flexible, allowing developers to create powerful web applications quickly.

Pros

High performance and low memory footprint
Extensive feature set, including WebSocket support, MVC architecture, and dependency injection
Active community and regular updates
Comprehensive documentation and examples

Cons

Steeper learning curve compared to some simpler Go web frameworks
Some users report occasional breaking changes between versions
Less widespread adoption compared to more established frameworks like Gin or Echo

Code Examples

Basic HTTP server:

package main

import "github.com/kataras/iris/v12"

func main() {
    app := iris.New()
    app.Get("/", func(ctx iris.Context) {
        ctx.JSON(iris.Map{"message": "Hello, World!"})
    })
    app.Listen(":8080")
}

Route parameters:

app.Get("/users/{id:uint64}", func(ctx iris.Context) {
    id, _ := ctx.Params().GetUint64("id")
    ctx.Writef("User ID: %d", id)
})

Middleware example:

app.Use(func(ctx iris.Context) {
    ctx.Application().Logger().Infof("New request: %s", ctx.Path())
    ctx.Next()
})

Getting Started

To start using Iris, follow these steps:

Install Iris:

go get github.com/kataras/iris/v12@latest

Create a new Go file (e.g., main.go) and add the following code:

package main

import "github.com/kataras/iris/v12"

func main() {
    app := iris.New()
    app.Get("/", func(ctx iris.Context) {
        ctx.HTML("<h1>Welcome to Iris!</h1>")
    })
    app.Listen(":8080")
}

Run your application:
```
go run main.go
```
Open your browser and visit http://localhost:8080 to see your Iris application in action.

Competitor Comparisons

gin

89,059

Pros of Gin

Lightweight and fast performance
Simple and intuitive API
Large community and ecosystem

Cons of Gin

Less built-in features compared to Iris
Limited middleware options out-of-the-box

Code Comparison

Gin:

r := gin.Default()
r.GET("/ping", func(c *gin.Context) {
    c.JSON(200, gin.H{"message": "pong"})
})
r.Run()

Iris:

app := iris.New()
app.Get("/ping", func(ctx iris.Context) {
    ctx.JSON(iris.Map{"message": "pong"})
})
app.Listen(":8080")

Key Differences

Iris offers more built-in features and middleware options
Gin focuses on simplicity and performance
Iris has a steeper learning curve but provides more flexibility
Gin has a larger community and more third-party packages

Performance

Both frameworks are known for their high performance, but Gin is often considered slightly faster in benchmarks.

Documentation

Gin has more extensive and well-maintained documentation, making it easier for newcomers to get started.

Community Support

Gin has a larger and more active community, resulting in more resources, tutorials, and third-party packages available.

echo

32,778

High performance, minimalist Go web framework

Pros of Echo

Simpler and more lightweight framework
Better documentation and community support
Faster performance in some benchmarks

Cons of Echo

Fewer built-in features compared to Iris
Less flexibility in routing and middleware configuration
Smaller ecosystem of third-party extensions

Code Comparison

Echo:

e := echo.New()
e.GET("/", func(c echo.Context) error {
    return c.String(http.StatusOK, "Hello, World!")
})
e.Logger.Fatal(e.Start(":1323"))

Iris:

app := iris.New()
app.Get("/", func(ctx iris.Context) {
    ctx.WriteString("Hello, World!")
})
app.Listen(":8080")

Both frameworks offer similar syntax for basic routing and handling, but Iris provides more built-in features and configuration options out of the box. Echo focuses on simplicity and performance, while Iris aims to be a more comprehensive framework with additional functionality.

Echo is generally easier to learn and use for beginners, while Iris offers more advanced features for complex applications. The choice between the two depends on the specific requirements of your project and personal preferences.

fiber

40,230

⚡️ Express inspired web framework written in Go

Pros of Fiber

Faster performance and lower memory usage
Simpler API with less boilerplate code
More active development and frequent updates

Cons of Fiber

Less mature and stable compared to Iris
Fewer built-in features and middleware options
Smaller community and ecosystem

Code Comparison

Iris:

app := iris.New()
app.Get("/", func(ctx iris.Context) {
    ctx.JSON(iris.Map{"message": "Hello, World!"})
})
app.Listen(":8080")

Fiber:

app := fiber.New()
app.Get("/", func(c *fiber.Ctx) error {
    return c.JSON(fiber.Map{"message": "Hello, World!"})
})
app.Listen(":8080")

Both Iris and Fiber are popular web frameworks for Go, offering high performance and ease of use. Fiber is known for its simplicity and speed, making it attractive for developers who prioritize performance. However, Iris has a longer history and offers more built-in features, which can be beneficial for complex applications.

The code comparison shows that both frameworks have similar syntax for basic routing and JSON responses. Fiber's approach is slightly more concise, aligning with its goal of simplicity. Ultimately, the choice between Iris and Fiber depends on specific project requirements and developer preferences.

mux

21,833

Package gorilla/mux is a powerful HTTP router and URL matcher for building Go web servers with 🦍

Pros of Mux

Lightweight and focused on routing, allowing for more flexibility in overall application structure
Well-established and widely used in the Go community, with extensive documentation and community support
Simple and straightforward API, making it easy to learn and use

Cons of Mux

Lacks built-in middleware and additional features, requiring integration with other libraries for full-stack development
No built-in view rendering or template engine support
Less performance optimization compared to Iris for high-concurrency scenarios

Code Comparison

Mux:

r := mux.NewRouter()
r.HandleFunc("/", HomeHandler)
r.HandleFunc("/products", ProductsHandler)
http.ListenAndServe(":8000", r)

Iris:

app := iris.New()
app.Get("/", HomeHandler)
app.Get("/products", ProductsHandler)
app.Listen(":8000")

Both Mux and Iris provide routing capabilities for Go web applications. Mux focuses primarily on routing, offering a simple and flexible approach. Iris, on the other hand, is a more comprehensive web framework with additional features like built-in middleware, view rendering, and websocket support.

Mux is ideal for developers who prefer a minimalist approach and want to build their stack from separate components. Iris suits those looking for an all-in-one solution with performance optimizations for high-concurrency scenarios.

httprouter

17,135

A high performance HTTP request router that scales well

Pros of httprouter

Lightweight and minimalistic, focusing solely on high-performance routing
Extremely fast and efficient, optimized for high-load scenarios
Easy to integrate with existing Go standard library components

Cons of httprouter

Limited built-in functionality compared to full-featured web frameworks
Lacks middleware support out of the box
May require additional libraries for more complex web applications

Code Comparison

httprouter:

router := httprouter.New()
router.GET("/", Index)
router.GET("/hello/:name", Hello)

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

Iris:

app := iris.New()
app.Get("/", Index)
app.Get("/hello/{name}", Hello)

app.Listen(":8080")

Summary

httprouter is a lightweight, high-performance HTTP request router for Go. It excels in speed and efficiency but offers limited built-in features. Iris, on the other hand, is a more comprehensive web framework with additional functionality and middleware support.

httprouter is ideal for projects requiring fast, simple routing, while Iris is better suited for larger applications needing a full-featured framework. The choice between them depends on the specific requirements of your project and the level of abstraction you prefer.

fasthttp

23,488

Fast HTTP package for Go. Tuned for high performance. Zero memory allocations in hot paths. Up to 10x faster than net/http

Pros of fasthttp

Significantly faster performance and lower memory usage
Designed for high-concurrency scenarios
Provides low-level control over HTTP operations

Cons of fasthttp

Less feature-rich compared to Iris
Steeper learning curve due to its low-level nature
Fewer built-in middleware and extensions

Code Comparison

Iris:

app := iris.New()
app.Get("/", func(ctx iris.Context) {
    ctx.JSON(iris.Map{"message": "Hello, World!"})
})
app.Listen(":8080")

fasthttp:

func handler(ctx *fasthttp.RequestCtx) {
    ctx.SetContentType("application/json")
    ctx.SetBody([]byte(`{"message": "Hello, World!"}`))
}
fasthttp.ListenAndServe(":8080", handler)

Summary

fasthttp is a high-performance, low-level HTTP library focused on speed and efficiency. It's ideal for projects requiring maximum performance but may require more manual implementation of features. Iris, on the other hand, is a full-featured web framework that provides a higher level of abstraction and more built-in functionality, making it easier to develop complex web applications quickly. The choice between the two depends on the specific requirements of your project, balancing between raw performance and development convenience.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

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 Ø§ÙØ¹Ø±Ø¨ÙØ©

â¡ 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

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:

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.

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!

ð Learning Iris

Installation

The only requirement is the Go Programming Language.

Create a new project

$ mkdir myapp
$ cd myapp
$ go mod init myapp
$ go get github.com/kataras/iris/v12@latest # or @v12.2.11

Install on existing project

$ cd myapp
$ go get github.com/kataras/iris/v12@latest

Run

$ go mod tidy -compat=1.23 # -compat="1.23" for windows.
$ go run .

Iris contains extensive and thorough documentation making it easy to get started with the framework.

For a more detailed technical documentation you can head over to our godocs. And for executable code you can always visit the ./_examples repository's subdirectory.

Develop with Plexon AI

Plexon AI is a cross-platform AI coding assistant from Hellenic Development, and it ships with a dedicated Iris skill: a v14 development guide written by the framework's author, with nineteen reference documents covering routing and macros, the context API, the rest helpers, error handling, all thirty middleware, the built-in controllers, the authentication SDK, security hardening, persistence, caching, i18n, observability, performance, testing, deployment, and the v12 to v14 migration.

Install the Software Developer persona and the Iris skill comes with it, alongside the engineering agents it activates. Your assistant then writes Iris code the way the framework is meant to be used, instead of guessing from whatever it picked up in training.

Do you like to read while traveling?

You can request a PDF and online access of the Iris E-Book (New Edition) today and take part in the development of Iris.

ð Contributing

We'd love to see your contribution to the Iris Web Framework! For more information about contributing to the Iris project please check the CONTRIBUTING.md file.

List of all Contributors

ð¡ Security Vulnerabilities

If you discover a security vulnerability within Iris, please send an e-mail to iris-go@outlook.com. All security vulnerabilities will be promptly addressed.

ð License

This project is licensed under the BSD 3-clause license, just like the Go project itself.

The project name "Iris" was inspired by the Greek mythology.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

Top Related Projects

Quick Overview

Pros

Cons

Code Examples

Getting Started

Competitor Comparisons

Pros of Gin

Cons of Gin

Code Comparison

Key Differences

Performance

Documentation

Community Support

Pros of Echo

Cons of Echo

Code Comparison

Pros of Fiber

Cons of Fiber

Code Comparison

Pros of Mux

Cons of Mux

Code Comparison

Pros of httprouter

Cons of httprouter

Code Comparison

Summary

Pros of fasthttp

Cons of fasthttp

Code Comparison

Summary

Convert designs to code with AI

README

News

Iris Web Framework Ø§ÙØ¹Ø±Ø¨ÙØ©

ð What is coming in Iris v14

The whole application in one compile-checked chain

Handlers stop repeating themselves

Errors are declared once

Dependency injection everywhere, not only in MVC

The packages are where you would expect them

Configuration is a partial literal

Names that say what they do

Secure by default

Documentation you can read start to finish

What it means for your v12 code

ð Supporters

ð Learning Iris

Installation

Create a new project

Develop with Plexon AI

Do you like to read while traveling?

ð Contributing

ð¡ Security Vulnerabilities

ð License

Top Related Projects

Convert designs to code with AI

Iris Web Framework Ø§ÙØ¹Ø±Ø¨ÙØ©

ð What is coming in Iris v14

ð Supporters

ð Learning Iris

ð Contributing

ð¡ Security Vulnerabilities

ð License