Kemal - Fast, Effective, Simple web framework for Crystal

Kemal 1.12.0 released!

Tue, 21 Jul 2026 03:00:00 +0000

Kemal is a Fast, Effective, Simple web framework for Crystal.

Hello everyone,

Kemal 1.12.0 is out :tada: This release brings Crystal 1.21.0 support and a first-class sse helper for Server-Sent Events, plus a handful of reliability and DX fixes.

Server-Sent Events with `sse` :zap:

You can now stream events to the client with a dedicated sse route helper—no manual header juggling required (#755):

sse "/events" do |stream, env|
  stream.send("tick", event: "tick", id: 1)
end

Ideal for live dashboards, notifications, and any one-way push where WebSockets would be overkill. Keep the connection open, send named events with optional ids, and let Kemal handle the SSE framing.

Crystal 1.21.0 support :crystal_ball:

Kemal 1.12.0 is tested and ready for Crystal 1.21.0. The minimum Crystal version is now >= 1.12.0—please upgrade your toolchain if you are still on an older release.

Fixes and polish :wrench:

Headers already sent: Avoid an unhandled exception when an error path tries to write headers that were already flushed to the client (#760).
before_all filters: Fixed filters running twice (#758).
CLI --help: Show the actual host/port defaults when they have been overridden (#751).

Full change history and PR links are in the CHANGELOG. Release tag: v1.12.0.

For end-to-end sample apps (blog, JSON API, WebSockets, OAuth, and more), see Kemal by Example on GitHub.

Thanks for using and supporting Kemal. You can help sustain development via GitHub Sponsors :pray:

Happy Crystalling :heart:

Kemal 1.11.0 released!

Mon, 13 Apr 2026 12:00:00 +0000

Kemal is a Fast, Effective, Simple web framework for Crystal.

Hello everyone,

Kemal 1.11.0 is out :tada: This release is focused on security hardening for multipart uploads and WebSocket connections. If you run Kemal in production, upgrading is strongly recommended :shield:

Chunked multipart limits :lock:

Multipart form parsing now respects safer limits for chunked bodies, closing a gap where very large fields could be abused (#748). Thanks @canermastan :pray:

You can cap the size of a single multipart form field (default is 8 MB):

Kemal.config.max_multipart_form_field_size = 8 * 1024 * 1024

Tune this to match your app (file uploads, API payloads, etc.) so legitimate traffic still flows while oversized fields are rejected early.

WebSocket origin validation :globe_with_meridians:

Browsers send an Origin header on WebSocket handshakes. Kemal can now validate that header against an allow list, so connections from unexpected sites are rejected (#749). Thanks @past3l :pray:

Kemal.config.websocket_allowed_origins = ["https://myapp.com", "http://localhost:3000"]

Use your real production origins (and local dev URLs) here. Without configuration, behavior stays compatible with existing apps; set the list when you want strict origin checks.

Full change history and PR links are in the CHANGELOG. Release tag: v1.11.0.

For end-to-end sample apps (blog, JSON API, WebSockets, OAuth, and more), see Kemal by Example on GitHub.

Thanks for using and supporting Kemal. You can help sustain development via GitHub Sponsors :pray:

Happy Crystalling :heart:

Kemal 1.10.0 released!

Tue, 03 Mar 2026 19:00:00 +0000

Kemal is a Fast, Effective, Simple web framework for Crystal.

Hello everyone,

Kemal 1.10.0 is here :tada: This is the biggest Kemal release to date: a modular router, a clearer way to plug in middleware, richer response helpers, and several reliability fixes across routing, the CLI, and request parsing :rocket:

Modular `Kemal::Router` :compass:

You can now build namespaced apps with scoped filters, WebSocket routes, and flexible mounting—while the classic top-level DSL stays fully supported.

require "kemal"

api = Kemal::Router.new

api.namespace "/users" do
  get "/" do |env|
    env.json({users: ["alice", "bob"]})
  end

  get "/:id" do |env|
    env.text "user #{env.params.url["id"]}"
  end
end

mount "/api/v1", api

Kemal.run

This makes it easier to organize large APIs, version routes, and reuse sub-applications without losing Kemal’s familiar style.

The `use` keyword for middleware :link:

Register global or path-specific middleware in one place. You can pass a single handler, an array of handlers, and control where they sit in the chain.

require "kemal"

# Path-specific middlewares for /api routes
use "/api", [CORSHandler.new, AuthHandler.new]

get "/" do
  "Public home"
end

get "/api/users" do |env|
  env.json({users: ["alice", "bob"]})
end

Kemal.run

Chainable response helpers :art:

Response helpers are chainable for JSON, HTML, text, and XML. They understand HTTP::Status (including symbols like :created), and you can halt with a fully built response—handy for short API error paths.

require "kemal"

get "/users" do |env|
  env.json({users: ["alice", "bob"]})
end

post "/users" do |env|
  env.status(:created).json({id: 1, created: true})
end

get "/admin" do |env|
  halt env.status(403).html("<h1>Forbidden</h1>")
end

get "/api/users" do |env|
  env.json({data: ["alice", "bob"]}, content_type: "application/vnd.api+json")
end

Kemal.run

Filters and routing correctness :white_check_mark:

Wildcard filters: Global wildcard filters now always run as intended, while namespace filters stay scoped to their routes—so behavior matches what you expect in modular apps.
Route LRU cache: The route lookup cache is now concurrency-safe thanks to a Mutex, which matters under parallel request handling.
OverrideMethodHandler: Fixed a route cache bug when using the _method parameter for HTTP verb override (e.g. in HTML forms).

CLI and request body :wrench:

CLI: SSL validation and option parsing were tightened, with expanded specs around CLI behavior.
ParamParser#raw_body: Handlers can read the raw body multiple times when needed (for example alongside kemal-session), while still using parsed body params elsewhere.

post "/" do |env|
  raw = env.params.raw_body  # raw body, multiple handlers can call it
  env.params.body["name"]    # parsed body
end

Thanks for using and supporting Kemal. Full details and links to the related pull requests are in the v1.10.0 release notes.

P.S: You can support Kemal development via Github Sponsors :pray:

Happy Crystalling :heart:

Kemal 1.9.0 released!

Thu, 29 Jan 2026 11:49:00 +0000

Kemal is a Fast, Effective, Simple web framework for Crystal.

Hello everyone,

Kemal 1.9.0 is here :tada: This release brings Crystal 1.19.0 support along with important security improvements and performance optimizations :rocket:

Crystal 1.19.0 Support :gem:

Kemal now fully supports Crystal 1.19.0, keeping up with the latest Crystal release. You can now enjoy all the new features and improvements that Crystal 1.19.0 brings to the table :heart:

Security Enhancement :shield:

This release includes an important security update that limits the maximum request body size to prevent DoS (Denial of Service) attacks. This protection ensures your Kemal applications are more resilient against malicious requests attempting to overwhelm your server with large payloads.

By default, Kemal now enforces sensible limits on incoming request body sizes, making your applications more secure out of the box :lock:

Performance Optimization :zap:

We’ve optimized JSON parameter parsing by directly using the request body IO instead of reading it into memory first. This improvement reduces memory allocations and speeds up JSON request handling, making your API endpoints even faster :fire:

Thanks for using and supporting Kemal. You can check the full CHANGELOG here.

P.S: You can support Kemal development via Github Sponsors :pray:

Happy Crystalling :heart:

Kemal 1.0 released!

Mon, 22 Mar 2021 20:21:00 +0000

Kemal is a Fast, Effective, Simple web framework written in Crystal.

Hello everyone,

I’m super excited and happy to release Kemal 1.0 on my birthday (Mar 22) right after Crystal 1.0. It’s the best birthday present I could ever wish for :birthday:

This release adds support for Crystal 1.0 and makes Kemal the first Crystal project to fully support Crystal 1.0.

It’s been a long ride and Kemal is 1.0 after:

733 Commits
601 Pull Requests
48 Releases
56 Contributors

and we’re just starting :rocket:

Thanks for using and supporting Kemal. You can check the full CHANGELOG here.

P.S: You can support Kemal development via Patreon :pray:

Happy Crystalling :heart:

Kemal 0.24.0 released!

Tue, 14 Aug 2018 14:21:00 +0000

Kemal is a Fast, Effective, Simple web framework written in Crystal.

Hello everyone,

Kemal 0.24.0 is here :tada:

This release brings support for Crystal 0.26.0 and adds new features. There are also some breaking changes.

New and Shiny Exception Page :star:

Thanks to the awesome exception_page shard, we got a new and shiny exception page implemented by @mamantoha :pray:

Custom Port Bindings :tada:

You can now bind a single Kemal server to multiple ports. Thanks to @straight-shoota :pray:

Kemal.run do |config|
  server = config.server.not_nil!
  server.bind_tcp "127.0.0.1", 3000
  server.bind_tcp "0.0.0.0", 3001
end

Breaking changes :hammer:

Removed env.params.files. You can use Crystal’s built-in HTTP::FormData.parse instead

post "/upload" do |env|
  HTTP::FormData.parse(env.request) do |upload|
    filename = file.filename

    if !filename.is_a?(String)
      "No filename included in upload"
    else
      file_path = ::File.join [Kemal.config.public_folder, "uploads/", filename]
      File.open(file_path, "w") do |f|
      IO.copy(file.tmpfile, f)
    end
    "Upload OK"
  end
end

From now on to access dynamic url params in a WebSocket route you have to use:

ws "/:id" do |socket, context|
  id = context.ws_route_lookup.params["id"]
end

Removed _method magic param from env.params.body.

Thanks for using and supporting Kemal. You can check the full CHANGELOG here.

P.S: You can support Kemal development via Patreon :pray:

Happy Crystalling :heart:

Kemal 0.21.0 released!

Tue, 05 Sep 2017 19:01:00 +0000

Kemal is a Fast, Effective, Simple web framework written in Crystal.

Hello everyone,

Kemal 0.21.0 is here :tada: This release brings long wanted features with more performance :rocket:

A long wanted feature, allows one to use HTTP::Server::Context in ws declarations :heart_eyes: This would allow accessing named url parameters and query parameters in WebSocket routes.

For example consider having a WebSocket url like

ws://myawesome.site/kemal?username=sdogruyol

Now you can access these variables from your url within your ws route :sunglasses:

ws "/:room_name" do |socket, env|
  env.params.url["room_name"] # => kemal
  env.params.query["username"] # => sdogruyol
end

Customizable Static File Headers :clap:

Another long wanted feature, which adds support for customizing the headers of built-in Kemal::StaticFileHandler :hammer: Useful for single page applications which rely on CORS.

Here’s a quick snippet for allowing CORS on .js files.

static_headers do |response, filepath, filestat|
  if filepath =~ /\.js$/
      response.headers.add("Access-Control-Allow-Origin", "*")
    end
  end
end

More Performance :rocket:

Kemal is built for being fast, we take performance seriously. In recent benchmarks we discovered that Kemal is being blazing fast :fire:

However, that’s not a reason to stop us from getting faster :fire: This release brings %10-%15 performance increase in overall execution times.

Thanks for using and supporting Kemal. You can check the full CHANGELOG here.

P.S: You can support Kemal development via Patreon :pray:

Happy Crystalling :heart:

Kemal 0.20.0 released!

Sat, 01 Jul 2017 18:55:00 +0000

Kemal is a Fast, Simple, Effective web framework written in Crystal.

Hello everyone,

Kemal 0.20.0 is here :tada: This release brings more modularity and performance :rocket:

Crystal 0.23.0 support ✨

The latest Crystal 0.23.0 release is already supported by Kemal. Just update your shard.yml to use Kemal 0.20.0 :sunglasses:

dependencies:
  kemal:
    github: kemalcr/kemal
    version: 0.20.0

Customizable Handlers :clap:

Great news everyone 🎉 All handlers are now completely customizable!. Use the default Kemal handlers or go wild to build your own custom framework, it’s all up to you ⛏

# Don't forget to add `Kemal::RouteHandler::INSTANCE` or your routes won't work!
Kemal.config.handlers = [Kemal::InitHandler.new, YourHandler.new, Kemal::RouteHandler::INSTANCE]

You can also insert a handler into a specific position.

# This adds MyCustomHandler instance to 1 position. Be aware that the index starts from 0.
add_handler MyCustomHandler.new, 1

Thanks for using and supporting Kemal. You can check the full CHANGELOG here.

P.S: You can support Kemal development via Patreon :pray:

Happy Crystalling :heart:

Kemal 0.18.1 released!

Tue, 21 Feb 2017 18:55:00 +0000

Hello everyone,

It’s just been 59 minutes since Crystal 0.21.0 is released and Kemal 0.18.1 is already here :rocket:

Crystal 0.21.0 support :heart:
Drop multipart.cr dependency. multipart support is now built-into Crystal <3
Since Crystal 0.21.0 comes built-in with multipart there are some minor changes.

meta has been removed from FileUpload and now it has the following properties

tmpfile: This is temporary file for file upload. Useful for saving the upload file.
filename: File name of the file upload. (logo.png, images.zip e.g)
headers: Headers for the file upload.
creation_time: Creation time of the file upload.
modification_time: Last Modification time of the file upload.
read_time: Read time of the file upload.
size: Size of the file upload.

P.S: File uploads are faster :fire:

Happy Crystalling!

Kemal 0.18.0 released!

Sat, 11 Feb 2017 18:55:00 +0000

Hello everyone,

Kemal 0.18.0 is here :tada: Kemal gets better yet becoming simpler :heartpulse:

Simpler File Upload

File uploads can now be accessed from request params like env.params.files["filename"].

It has 5 useful methods to get the job done!

tmpfile: This is the temporary file for file upload. Useful for saving or manipulating the upload file.
tmpfile_path: File path of tmpfile.
filename: File name of the file upload. (logo.png, images.zip e.g)
meta: Meta information for the file upload.
headers: Request headers for the file upload.

Here’s a fully working sample for reading an image file upload with key image1 and saving it under public/uploads.

post "/upload" do |env|
  file = env.params.files["image1"].tmpfile
  file_path = ::File.join [Kemal.config.public_folder, "uploads/", file.filename]
  File.open(file_path, "w") do |f|
    IO.copy(file, f)
  end
  "Upload ok"
end

You can test this with below curl command.

curl -F "image1=@/Users/serdar/Downloads/kemal.png" http://localhost:3000/upload

File Streaming

Streaming is a serious business and Kemal has you covered :sunglasses: This release adds RFC7233 support.

What this practically means is that you can partially request a file from Kemal without downloading the rest by utilizing HTTP Range header. Ain’t that cool :sushi:

Be sure to check out the full CHANGELOG for the full awesomeness and bug fixes :) And a big THANKS to everyone for making this release possible :heart:

Happy Crystalling!

Kemal - Fast, Effective, Simple web framework for Crystal

Kemal 1.12.0 released!

Server-Sent Events with sse :zap:

Crystal 1.21.0 support :crystal_ball:

Fixes and polish :wrench:

Kemal 1.11.0 released!

Chunked multipart limits :lock:

WebSocket origin validation :globe_with_meridians:

Kemal 1.10.0 released!

Modular Kemal::Router :compass:

The use keyword for middleware :link:

Chainable response helpers :art:

Filters and routing correctness :white_check_mark:

CLI and request body :wrench:

Kemal 1.9.0 released!

Crystal 1.19.0 Support :gem:

Security Enhancement :shield:

Performance Optimization :zap:

Kemal 1.0 released!

Kemal 0.24.0 released!

New and Shiny Exception Page :star:

Custom Port Bindings :tada:

Breaking changes :hammer:

Kemal 0.21.0 released!

WebSocket Context :cookie:

Customizable Static File Headers :clap:

More Performance :rocket:

Kemal 0.20.0 released!

Crystal 0.23.0 support ✨

Customizable Handlers :clap:

Kemal 0.18.1 released!

Kemal 0.18.0 released!

Simpler File Upload

File Streaming

More

Server-Sent Events with `sse` :zap:

Modular `Kemal::Router` :compass:

The `use` keyword for middleware :link: