Howdy
HowdySay hello to your next idea.

Big ideas.
Happy building.

The full-featured web framework written in Gleam. Typed from end to end and running on the BEAM.

curl -fsSL https://tryhowdy.dev/install.sh | bash
Let’s build something Explore the docs
hello_controller.gleam
import howdy/controller
import howdy/param

pub fn controller() {
  controller.new("/hello")
  |> controller.get("/:name", fn(ctx) {
    use name <- param.string(ctx, "name")
    controller.text(ctx, "Howdy, " <> name <> "! 👋")
  })
}

A route is a function.

  • Controllers group routes under a prefix
  • Typed path, query and form parameters
  • Guards, CORS, CSRF and rate limiting as middleware
Read the guide
counter.gleam
pub fn app() {
  lustre.simple(init, update, view)
}

fn update(count: Int, msg: Msg) -> Int {
  case msg {
    Increment -> count + 1
    Decrement -> count - 1
  }
}

fn view(count: Int) {
  ui.card([], [
    ui.h2("Counter"),
    ui.p([text(int.to_string(count))]),
    ui.button(Primary, [event.on_click(Increment)], [text("+")]),
  ])
}

Interactive, without the JavaScript.

  • State and logic stay on the server
  • The browser gets only what changed, over a WebSocket
  • Built from Howdy UI’s themed components
Read the guide
todos.gleam
pub fn open(db: Repo) -> service.Result(List(Todo)) {
  query.from(todo_item.table())
  |> query.where(query.Eq("done", sql.bool(False)))
  |> query.order_by("id", query.Asc)
  |> repo.query_all(db, _)
  |> result.map_error(errors.from_db)
}

Queries you can read.

  • PostgreSQL or SQLite through Gloo
  • Migrations that run when the app starts
  • Transactions, and errors as values
Read the guide
hello_controller_test.gleam
pub fn hello_test() {
  let res =
    testing.get("/hello/world")
    |> testing.send(app())

  assert res.status == 200
  assert testing.text(res) == "Howdy, world! 👋"
}

Tests without a server.

  • Requests go straight through your app
  • Check status, headers, cookies, JSON and HTML
  • A fresh database for every test
Read the guide
Live, right now

This box is running
on our server.

Type your name. Each key press travels up a WebSocket, Gleam runs the update on the BEAM, and only the changed text comes back. No JavaScript was written for it, and no JSON API.

  1. 1You type
  2. 2The server updates
  3. 3The page patches
How live components work
Connected to Howdy
All the right pieces

Everything a real app needs,
already on speaking terms.

01 / Routing

Small steps. Big ship.

Controllers, typed parameters, cookies, forms and guards. Hot reload keeps you moving, and the BEAM keeps it up.

controller.get("/:id", show)
02 / Live UI

Pages that feel alive.

Howdy UI’s themed components on the server, and live components that update over a WebSocket.

live.mount("/live/todos")
03 / Data

A database you can trust.

PostgreSQL or SQLite through Gloo, with migrations, transactions and errors you handle as values.

repo.query_all(db, query)
04 / Auth

Confidence, built in.

Passwords, passkeys, MFA and SSO, with groups and roles. Secure cookie defaults and explicit access guards.

howdy add auth
05 / Admin

See every request.

Browse your database and follow each request as a trace of its queries and logs, at /_howdy while you develop.

admin.mount(dashboard)
06 / Testing

Tests at the speed of thought.

Send requests through your app with no socket and no mocks, against a fresh database each time.

testing.send(req, app)
~/my_appzsh
$ howdy create pages posts post \
    title:string body:string

🤠 Creating files
  + src/my_app/features/posts/post.gleam
  + src/my_app/features/posts/posts.gleam
  + src/my_app/features/posts/posts_controller.gleam
  + src/my_app/features/posts/pages/index_page.gleam
  + src/my_app/features/posts/pages/show_page.gleam
  + src/my_app/features/posts/pages/new_page.gleam
  + src/my_app/features/posts/pages/edit_page.gleam
  + src/my_app/migrations/create_posts.gleam
  + test/my_app/features/posts/posts_test.gleam
✓ Registered the routes and migration
Generate, don’t type

One command.
A whole feature.

The howdy CLI writes a record, its database operations, a migration, pages to list, show, add, edit and delete, and tests for all of it. Then it registers the routes for you.

  • howdy new a project
  • howdy create pages, APIs, live components
  • howdy add auth, mail, flags, OpenAPI
See every generator
Go exploring

Pull up a chair.

68 guides

Documentation

From your first route to passkeys, clusters and tracing. Written beside the code and released with it.

61 entries

Components

Every Howdy UI component, block and theme, drawn live beside the code that drew it.

Light + dark

Theme maker

Pick your colours, watch real components redraw, check the contrast, and download a Gleam module.

Hello, possibility

Up and running in three steps.

You’ll need Gleam, Erlang and rebar3. The getting started guide covers installing them.

  1. 1

    Install the CLI

    curl -fsSL https://tryhowdy.dev/install.sh | bash
  2. 2

    Create a project

    howdy new my_app
  3. 3

    Start building

    cd my_app && gleam dev

Your next project
starts with a howdy.

Built with Gleam. Made for your imagination.

Read the guide Star on GitHub