build(deps): bump instability from 0.3.10 to 0.3.11

Bumps [instability](https://github.com/ratatui/instability) from 0.3.10 to 0.3.11.
- [Release notes](https://github.com/ratatui/instability/releases)
- [Changelog](https://github.com/ratatui/instability/blob/main/CHANGELOG.md)
- [Commits](https://github.com/ratatui/instability/compare/instability-v0.3.10...instability-v0.3.11)

---
updated-dependencies:
- dependency-name: instability
  dependency-version: 0.3.11
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

.cargo-husky/hooks/pre-push

@@ -1,16 +0,0 @@
-#!/usr/bin/env bash
-
-if !(command cargo-make >/dev/null 2>&1); then # Check if cargo-make is installed
-    echo Attempting to run cargo-make as part of the pre-push hook but it\'s not installed.
-    echo Please install it by running the following command:
-    echo
-    echo "    cargo install --force cargo-make"
-    echo
-    echo If you don\'t want to run cargo-make as part of the pre-push hook, you can run
-    echo the following command instead of git push:
-    echo
-    echo "    git push --no-verify"
-    exit 1
-fi
-
-cargo make ci

.cargo/config.toml

@@ -0,0 +1,2 @@
+[alias]
+xtask = "run --package xtask --"

.cliffignore

@@ -0,0 +1,115 @@
+# skip entries from <https://github.com/ratatui/ratatui/pull/1652>
+50af9a5d80ed5446f3e6cc554911f606580edde9
+272e9709c6eed45cd7e0c183624b7898f4e0ae69
+adc8fdc35aa57d6dad2ae8dd30ec2e9256576c09
+31711dbf82a4c7bb3b78692da34d9f469725dd6e
+b6356aa7a529a491d63dd6628b8985adae337f16
+885558b6f89df642317d39c5b44c94c742d1e0c8
+6440eb9d76379340953420629ab0a3d9039d6c48
+3870583ea868452191857f9bda97a3d5c35d0a4f
+487edc8399683fb8a9a66359729c015780d248f2
+250c222cc4aaab09184a28efc68f75ca03133794
+590a392ab11c1a215767614931036781f4cf6a29
+6443f7408af4a8834bc68cd35d2ba9be47e45f38
+8339cce10a51c9c951b3c9750d527d80168626eb
+ac342231c344e893f2f630ee38167aab28c736a6
+0fb103680028a6e26a1923f87b60bde51acaec4f
+4335a90a00aeeedb69a92442c7f2711727944017
+71480242a926f98e9081ed6e2dc8c381757b3a42
+e1a31db55913bd690bcaef380e9dbc3b6a5dc175
+38490ff8da6f11e309ba1bcb3e88a562f7c953c5
+a4bb143e4767137d6a9e9927d3da66562611f86f
+bc73f2dcbe5ea48fc4d1555a8e931f40d7b0e03f
+77dea441e5637b1c428c2aa71ea67fb3aac20c12
+06af14107e70e49a4cba3babb8ab0a0c57b4bdf8
+9acdab32df69517b93dd2b861b85586d47c71540
+2e684c6500be61fbe69744d183c8086564ac0051
+b7f8ec0ff9659473d936eae53a57cd9de38cec1f
+31a2c4548c304270a8c852f19baa7a4eaac5e75c
+57b681b053c019b66e0ed92959638997fea731b1
+131b9ec41751163d43d94564363247b60f031486
+8b32f82b4dd526580d00fa13f053bf507e8ea933
+76d1e5b1733d47a7f05acf563db26cb1a66b540d
+57a0a34f924e0d488c9e9f917900e677c3488dc4
+12aa58601ddd0704256c56019bd2c7139d41f7a2
+2dc81833c60951d16f9bd60f3da003edfc9a11f5
+20e41f1d1da6db8abbc2504814531d4d97bdf94b
+68b55a12a29e70ebfcc063c2d5d5845de3b5a27e
+693003314a25e792ffc5d53146b28bfb6a4582e3
+63441e259bc38b56e0369197bed14788b2cb3d54
+fa88152c808eeb6c9d9b3662361aab1e57e1b1bf
+30d9daa59b1843786cde00e25c3e69cfe818b80b
+92540b2f6ab25f3a5400aebb28af3c498ac793a4
+29edc3a7a38c512611a80cf5d8d42027558419b2
+819499d6ffc0e8453ed3220067645933a4882a74
+4756526829a4e849d9e256b6cf821eb66afe3ade
+8f35437d5ad78d31cd45c4af888f20f0b5ab4196
+39bd72b1f702dadb1ebbaf4e77ad2fada166ac49
+c6d2cee3e967c9234176c5229858512b0c79d6a9
+bd90e3d928e0f9f0b915933ebbc32c2256fe8cfa
+b820c0c7e4c576c1e39b5e482a8aac08076a039c
+74194759756bb111b4da3e9a5cdb968275a2fab0
+38b2f27efe0e1829bc503df7fd64b94b7bb80d97
+21aa3232d762d6e3f81f15fc5b66ba462385ac05
+903bb0ae32d22393783edfda96db900739864f0a
+5cee13ab6d9c49751cf9283d9099e37f0cc3632c
+0a0997702dd4cf2217160f5652f5c39cbd4a1010
+778f2f5ec511bef431b54157242b91d083ea9840
+7d23bd2ceaf96e81972b5f746fdcba0d17f6391f
+2c02a56bce31519386303571e0b66b7d4beb378e
+f33d51e7d9ccf9fe52ec3289d04d97c722d9ee17
+91cd81aaa032887bb2327bc3fe3cad6b3c9fbacf
+5d5a1ccb0b4e2f293f215ce026fba33f1c069689
+6b9417db5f2adbdc60e9dd8dc5acbbe2a1f77ba9
+dce1e4b138eb1333c9e773bacd579a8cdddd73fb
+b4aacb045e2200896b0d0136a2b8688b47828d73
+dcba0bcd5d5d6e33ddc1fa94ebb94819fdda600e
+6f52350ecfb62e3a5bac16f0824e74b757cc6cd2
+2c6f324b9aa5034771e00758b143fd8df94d859d
+bf0210602948f8d26ae323996fe7b22fb218a446
+07aff91b015b5e7e0504680c12edbce70d7dba1e
+f6d49dde14af73ed467d75d8f6ec0f502db2908f
+9a7467b30576d5cb7491ea6e09efcae97eadf9bb
+a0c35f1d7bcce10e092582b95f5b0a3f20ad7bf3
+d24747d46982192b575a40b8cc18d1c948fac3d7
+8060f7bc578b29dde6ca0c4c64569f9c73218f46
+0dc5b2d2e0aa6438ffc1b3965b1ab31c721adbcc
+8ecdd892f53d7db95bbb53a61700d36e3fcefdd4
+570c35868147a2400a13331e85d562d1ef96a011
+3855c3a84a77037aeee40dbe9e52454fb1f9afee
+93372f35c1669da0138ca776890f3ff3d38a6539
+6cf08d4a2f0398856fd593f50bf077fd59b08230
+f78d3bfec32d07c1124eee8d0249477ce3fb0884
+204307fa50aaaa373946342084f7fd3af39f3cd3
+c50b01d098e5ab405a50c3e14e858da27d606e8f
+f71d1ac73e8290f37d55a67d6a6507a3653ec174
+ae2868c0e0b1ac8b5126fd43269383fa533d87b5
+be8def963956c605bca28bcd8df673bd7ec3740b
+4ac4d9d3ab97176d71e287bcdd6d41e66f2f7ccb
+fafabb8dab84e9460a076199ea646262e51c855b
+2f97d35bd8618e8c0cc006cb1d4a9b151c1b9b4a
+39d5a745acbbd3510de707d4e7c471c17e02ae59
+a1acdcdc4c002390a76f01699cfa006a36cf3f56
+ad54cf29ad1a4335ba208fb94a8fc5dfbba260e3
+c7649575e7b199794be4252f79da80aaecdcee28
+8913e2ce1f40d451ddb4527f08ec75f198d5063c
+1b9e310300f22bfc72364f027a9caeddadf61a99
+89d7dd46031511f0556b2d29ab34035f42e3a24c
+ca4fa0b9bf5ba707aa0447ba7c38fbacdadb7eec
+8cecfdf2f6dd5b0de507f79b469517cc0fb42add
+7eeb6afb3dbc56e52f9387a74f826b186cd19137
+d0f75eb371a96f8d5f174e23de074efd840e9e44
+f8a70ea9da8e6df2bf7a5f74cce45615fc292afe
+f28b9730061bffadb9d87ad63edf7d10b245d2c1
+afc5cf2140f22fea6bd6933dd0f9c302229a1980
+b75df78cdca58d5dca0c51fb8e106067aa6cb752
+28f5a6dbd4091aa3efa86eed6767eeb44a655f0f
+345e6a1ebd853858463a33953585ce407a60378c
+c45a4de47c601554f6b981d211181468b4798e41
+bbaa9a5432ff6ad5518344123c3b56f349347e99
+f804c90f96221f334371ccd01b0e6df7b1cfc1e8
+16ba867c5877d8c97968987ecb5f8bff966d0a82
+38a1474ca12aa6a796afc1e277882d997a999e14
+92c4078413fc79fcc83f5d3d8708abb58696ff1a
+d4415204e1eb3aed2a74a722aeaaa274975dd2d7
+e48bcf5f21f14acb27996fdc02231c140f5b817c

.cz.toml

@@ -32,17 +32,17 @@ schema_pattern = "(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)
 type = "list"
 name = "change_type"
 choices = [
-    { value = "build", name = "build: Changes that affect the build system or external dependencies (example scopes: pip, docker, npm)", key = "b" },
-    { value = "chore", name = "chore: A modification that generally does not fall into any other category", key = "c" },
-    { value = "ci", name = "ci: Changes to our CI configuration files and scripts (example scopes: GitLabCI)", key = "i" },
-    { value = "docs", name = "docs: Documentation only changes", key = "d" },
-    { value = "feat", name = "feat: A new feature.", key = "f" },
-    { value = "fix", name = "fix: A bug fix.", key = "x" },
-    { value = "perf", name = "perf: A code change that improves performance", key = "p" },
-    { value = "refactor", name = "refactor: A code change that neither fixes a bug nor adds a feature", key = "r" },
-    { value = "revert", name = "revert: Revert previous commits", key = "v" },
-    { value = "style", name = "style: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)", key = "s" },
-    { value = "test", name = "test: Adding missing or correcting existing tests", key = "t" },
+  { value = "build", name = "build: Changes that affect the build system or external dependencies (example scopes: pip, docker, npm)", key = "b" },
+  { value = "chore", name = "chore: A modification that generally does not fall into any other category", key = "c" },
+  { value = "ci", name = "ci: Changes to our CI configuration files and scripts (example scopes: GitLabCI)", key = "i" },
+  { value = "docs", name = "docs: Documentation only changes", key = "d" },
+  { value = "feat", name = "feat: A new feature.", key = "f" },
+  { value = "fix", name = "fix: A bug fix.", key = "x" },
+  { value = "perf", name = "perf: A code change that improves performance", key = "p" },
+  { value = "refactor", name = "refactor: A code change that neither fixes a bug nor adds a feature", key = "r" },
+  { value = "revert", name = "revert: Revert previous commits", key = "v" },
+  { value = "style", name = "style: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)", key = "s" },
+  { value = "test", name = "test: Adding missing or correcting existing tests", key = "t" },
 ]
 message = "Select the type of change you are committing"
 

.github/CODEOWNERS

@@ -1,11 +1,11 @@
-# See https://help.github.com/articles/about-codeowners/
+# See <https://help.github.com/articles/about-codeowners/>
+
 # for more info about CODEOWNERS file
 
 # It uses the same pattern rule for gitignore file
-# https://git-scm.com/docs/gitignore#_pattern_format
+
+# <https://git-scm.com/docs/gitignore#_pattern_format>
 
 # Maintainers
-* @orhun @joshka @kdheepak @Valentin271 @EdJoPaTo
 
-# Past maintainers
-# @mindoodoo @sayanarijit
+* @ratatui/maintainers

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: ratatui
+open_collective: ratatui

.github/ISSUE_TEMPLATE/bug_report.md

@@ -2,7 +2,7 @@
 name: Bug report
 about: Create an issue about a bug you encountered
 title: ''
-labels: bug
+labels: 'Type: Bug'
 assignees: ''
 ---
 
@@ -17,26 +17,22 @@ A detailed and complete issue is more likely to be processed quickly.
 A clear and concise description of what the bug is.
 -->
 
-
 ## To Reproduce
 <!--
 Try to reduce the issue to a simple code sample exhibiting the problem.
 Ideally, fork the project and add a test or an example.
 -->
 
-
 ## Expected behavior
 <!--
 A clear and concise description of what you expected to happen.
 -->
 
-
 ## Screenshots
 <!--
 If applicable, add screenshots, gifs or videos to help explain your problem.
 -->
 
-
 ## Environment
 <!--
 Add a description of the systems where you are observing the issue. For example:

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,11 @@
 blank_issues_enabled: false
 contact_links:
+  - name: Frequently Asked Questions
+    url: https://ratatui.rs/faq/
+    about: Check the website FAQ section to see if your question has already been answered
+  - name: Ratatui Forum
+    url: https://forum.ratatui.rs
+    about: Ask questions about ratatui on our Forum
   - name: Discord Chat
     url: https://discord.gg/pMCEU9hNEj
     about: Ask questions about ratatui on Discord

.github/ISSUE_TEMPLATE/feature_request.md

@@ -2,7 +2,7 @@
 name: Feature request
 about: Suggest an idea for this project
 title: ''
-labels: enhancement
+labels: 'Type: Enhancement'
 assignees: ''
 
 ---

.github/copilot-instructions.md

@@ -0,0 +1,81 @@
+# GitHub Copilot Code Review Instructions
+
+## General Review Principles
+
+### Pull Request Size and Scope
+- **Flag large PRs**: Comment if a PR changes more than 500 lines or touches many unrelated areas
+- **Suggest splitting**: Recommend breaking large changes into smaller, focused PRs
+- **Question scope creep**: Ask about unrelated changes that seem outside the PR's stated purpose
+
+### Code Quality and Style
+- **Check adherence to style guidelines**: Verify changes follow the project's Rust conventions in [CONTRIBUTING.md](https://github.com/ratatui/ratatui/blob/main/CONTRIBUTING.md#code-formatting)
+- **Verify xtask compliance**: Ensure `cargo xtask format` and `cargo xtask lint` would pass
+- **Look for AI-generated patterns**: Be suspicious of verbose, overly-commented, or non-idiomatic code
+
+### Architectural Considerations
+- **Reference ARCHITECTURE.md**: Point to [ARCHITECTURE.md](https://github.com/ratatui/ratatui/blob/main/ARCHITECTURE.md) for changes affecting crate boundaries
+- **Question fundamental changes**: Flag modifications to core configuration, linting rules, or build setup without clear justification
+- **Verify appropriate crate placement**: Ensure changes are in the correct crate per the modular structure
+
+### Breaking Changes and Deprecation
+- **Require deprecation**: Insist on deprecation warnings rather than immediate removal of public APIs
+- **Ask for migration path**: Request clear upgrade instructions for breaking changes
+- **Suggest feature flags**: Recommend feature flags for experimental or potentially disruptive changes
+- **Reference versioning policy**: Point to the requirement of at least one version notice before removal
+
+### Testing and Documentation
+- **Verify test coverage**: Ensure new functionality includes appropriate tests
+- **Check for test removal**: Question any removal of existing tests without clear justification
+- **Require documentation**: Ensure public APIs are documented with examples
+- **Validate examples**: Check that code examples are minimal and follow project style
+
+### Specific Areas of Concern
+
+#### Configuration Changes
+- **Lint configuration**: Question changes to `.clippy.toml`, `rustfmt.toml`, or CI configuration
+- **Cargo.toml modifications**: Scrutinize dependency changes or workspace modifications
+- **Build system changes**: Require justification for xtask or build process modifications
+
+#### Large Code Additions
+- **Question necessity**: Ask if large code additions could be implemented more simply
+- **Check for duplication**: Look for code that duplicates existing functionality
+- **Verify integration**: Ensure new code integrates well with existing patterns
+
+#### File Organization
+- **Validate module structure**: Ensure new modules follow the project's organization
+- **Check import organization**: Verify imports follow the std/external/local grouping pattern
+- **Review file placement**: Confirm files are in appropriate locations per ARCHITECTURE.md
+
+## Comment Templates
+
+### For Large PRs
+```
+This PR seems quite large with changes across multiple areas. Consider splitting it into smaller, focused PRs:
+- Core functionality changes
+- Documentation updates  
+- Test additions
+- Configuration changes
+
+See our [contribution guidelines](https://github.com/ratatui/ratatui/blob/main/CONTRIBUTING.md#keep-prs-small-intentional-and-focused) for more details.
+```
+
+### For Breaking Changes
+```
+This appears to introduce breaking changes. Please consider:
+- Adding deprecation warnings instead of immediate removal
+- Providing a clear migration path in the PR description
+- Following our [deprecation policy](https://github.com/ratatui/ratatui/blob/main/CONTRIBUTING.md#deprecation-notice)
+```
+
+### For Configuration Changes
+```
+Changes to project configuration (linting, formatting, build) should be discussed first. Please explain:
+- Why this change is necessary
+- What problem it solves
+- Whether it affects contributor workflow
+```
+
+### For Style Issues
+```
+Please run `cargo xtask format` and `cargo xtask lint` to ensure code follows our style guidelines. See [CONTRIBUTING.md](https://github.com/ratatui/ratatui/blob/main/CONTRIBUTING.md#code-formatting) for details.
+```

.github/workflows/calculate-alpha-release.bash

@@ -1,52 +0,0 @@
-#!/bin/bash
-
-# Exit on error. Append "|| true" if you expect an error.
-set -o errexit
-# Exit on error inside any functions or subshells.
-set -o errtrace
-# Do not allow use of undefined vars. Use ${VAR:-} to use an undefined VAR
-set -o nounset
-# Catch the error in case mysqldump fails (but gzip succeeds) in `mysqldump |gzip`
-set -o pipefail
-# Turn on traces, useful while debugging but commented out by default
-# set -o xtrace
-
-last_release="$(git tag --sort=committerdate | grep -P "v0+\.\d+\.\d+$" | tail -1)"
-echo "🐭 Last release: ${last_release}"
-
-# detect breaking changes
-if [ -n "$(git log --oneline ${last_release}..HEAD | grep '!:')" ]; then
-    echo "🐭 Breaking changes detected since ${last_release}"
-    git log --oneline ${last_release}..HEAD | grep '!:'
-    # increment the minor version
-    minor="${last_release##v0.}"
-    minor="${minor%.*}"
-    next_minor="$((minor + 1))"
-    next_release="v0.${next_minor}.0"
-else
-    # increment the patch version
-    patch="${last_release##*.}"
-    next_patch="$((patch + 1))"
-    next_release="${last_release/%${patch}/${next_patch}}"
-fi
-echo "🐭 Next release: ${next_release}"
-
-suffix="alpha"
-last_tag="$(git tag --sort=committerdate | tail -1)"
-if [[ "${last_tag}" = "${next_release}-${suffix}"* ]]; then
-    echo "🐭 Last alpha release: ${last_tag}"
-    # increment the alpha version
-    # e.g. v0.22.1-alpha.12 -> v0.22.1-alpha.13
-    alpha="${last_tag##*-${suffix}.}"
-    next_alpha="$((alpha + 1))"
-    next_tag="${last_tag/%${alpha}/${next_alpha}}"
-else
-    # increment the patch and start the alpha version from 0
-    # e.g. v0.22.0 -> v0.22.1-alpha.0
-    next_tag="${next_release}-${suffix}.0"
-fi
-# update the crate version
-msg="# crate version"
-sed -E -i "s/^version = .* ${msg}$/version = \"${next_tag#v}\" ${msg}/" Cargo.toml
-echo "NEXT_TAG=${next_tag}" >> $GITHUB_ENV
-echo "🐭 Next alpha release: ${next_tag}"

.github/workflows/cd.yml

@@ -1,66 +0,0 @@
-name: Continuous Deployment
-
-on:
-  workflow_dispatch:
-  schedule:
-    # At 00:00 on Saturday
-    # https://crontab.guru/#0_0_*_*_6
-    - cron: "0 0 * * 6"
-  push:
-    tags:
-      - "v*.*.*"
-
-defaults:
-  run:
-    shell: bash
-
-jobs:
-  publish-alpha:
-    name: Create an alpha release
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    if: ${{ !startsWith(github.event.ref, 'refs/tags/v') }}
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Calculate the next release
-        run: .github/workflows/calculate-alpha-release.bash
-
-      - name: Publish on crates.io
-        uses: actions-rs/cargo@v1
-        with:
-          command: publish
-          args: --allow-dirty --token ${{ secrets.CARGO_TOKEN }}
-
-      - name: Generate a changelog
-        uses: orhun/git-cliff-action@v3
-        with:
-          config: cliff.toml
-          args: --unreleased --tag ${{ env.NEXT_TAG }} --strip header
-        env:
-          OUTPUT: BODY.md
-
-      - name: Publish on GitHub
-        uses: ncipollo/release-action@v1
-        with:
-          tag: ${{ env.NEXT_TAG }}
-          prerelease: true
-          bodyFile: BODY.md
-
-  publish-stable:
-    name: Create a stable release
-    runs-on: ubuntu-latest
-    if: ${{ startsWith(github.event.ref, 'refs/tags/v') }}
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v4
-
-      - name: Publish on crates.io
-        uses: actions-rs/cargo@v1
-        with:
-          command: publish
-          args: --token ${{ secrets.CARGO_TOKEN }}

.github/workflows/check-pr.yml

@@ -1,6 +1,13 @@
 name: Check Pull Requests
 
+# Set the permissions of the github token to the minimum and only enable what is needed
+# See https://docs.github.com/en/actions/security-guides/automatic-token-authentication#permissions
+permissions: {}
+
 on:
+  # this workflow is required to be run on pull_request_target as it modifies the PR comments
+  # care should be taken that the jobs do not run any untrusted input
+  # zizmor: ignore[dangerous-triggers]
   pull_request_target:
     types:
       - opened
@@ -8,23 +15,21 @@ on:
       - synchronize
       - labeled
       - unlabeled
-  merge_group:
-
-permissions:
-  pull-requests: write
 
 jobs:
   check-title:
+    permissions:
+      pull-requests: write
     runs-on: ubuntu-latest
     steps:
       - name: Check PR title
         if: github.event_name == 'pull_request_target'
-        uses: amannn/action-semantic-pull-request@v5
+        uses: amannn/action-semantic-pull-request@48f256284bd46cdaab1048c3721360e808335d50 # v5
         id: check_pr_title
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
       # Add comment indicating we require pull request titles to follow conventional commits specification
-      - uses: marocchino/sticky-pull-request-comment@v2
+      - uses: marocchino/sticky-pull-request-comment@773744901bac0e8cbb5a0dc842800d45e9b2b405 # v2
         if: always() && (steps.check_pr_title.outputs.error_message != null)
         with:
           header: pr-title-lint-error
@@ -39,40 +44,42 @@ jobs:
 
       # Delete a previous comment when the issue has been resolved
       - if: ${{ steps.check_pr_title.outputs.error_message == null }}
-        uses: marocchino/sticky-pull-request-comment@v2
+        uses: marocchino/sticky-pull-request-comment@773744901bac0e8cbb5a0dc842800d45e9b2b405 # v2
         with:
           header: pr-title-lint-error
           delete: true
 
   check-breaking-change-label:
+    permissions:
+      pull-requests: write
     runs-on: ubuntu-latest
     env:
       # use an environment variable to pass untrusted input to the script
       # see https://securitylab.github.com/research/github-actions-untrusted-input/
       PR_TITLE: ${{ github.event.pull_request.title }}
     steps:
-    - name: Check breaking change label
-      id: check_breaking_change
-      run: |
-        pattern='^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\(\w+\))?!:'
-        # Check if pattern matches
-        if echo "${PR_TITLE}" | grep -qE "$pattern"; then
-          echo "breaking_change=true" >> $GITHUB_OUTPUT
-        else
-          echo "breaking_change=false" >> $GITHUB_OUTPUT
-        fi
-    - name: Add label
-      if: steps.check_breaking_change.outputs.breaking_change == 'true'
-      uses: actions/github-script@v7
-      with:
-        github-token: ${{ secrets.GITHUB_TOKEN }}
-        script: |
-          github.rest.issues.addLabels({
-            issue_number: context.issue.number,
-            owner: context.repo.owner,
-            repo: context.repo.repo,
-            labels: ['breaking change']
-          })
+      - name: Check breaking change label
+        id: check_breaking_change
+        run: |
+          pattern='^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\(\w+\))?!:'
+          # Check if pattern matches
+          if echo "${PR_TITLE}" | grep -qE "$pattern"; then
+            echo "breaking_change=true" >> $GITHUB_OUTPUT
+          else
+            echo "breaking_change=false" >> $GITHUB_OUTPUT
+          fi
+      - name: Add label
+        if: steps.check_breaking_change.outputs.breaking_change == 'true'
+        uses: actions/github-script@v8
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            github.rest.issues.addLabels({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              labels: ['Type: Breaking Change']
+            })
 
   do-not-merge:
     if: ${{ contains(github.event.*.labels.*.name, 'do not merge') }}

.github/workflows/check-semver.yml

@@ -0,0 +1,22 @@
+name: Check Semver
+
+# Set the permissions of the github token to the minimum and only enable what is needed
+# See https://docs.github.com/en/actions/security-guides/automatic-token-authentication#permissions
+permissions: {}
+
+on:
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  check-semver:
+    name: Check semver
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+      - name: Check semver
+        uses: obi1kenobi/cargo-semver-checks-action@5b298c9520f7096a4683c0bd981a7ac5a7e249ae # v2

.github/workflows/ci.yml

@@ -1,5 +1,9 @@
 name: Continuous Integration
 
+# Set the permissions of the github token to the minimum and only enable what is needed
+# See https://docs.github.com/en/actions/security-guides/automatic-token-authentication#permissions
+permissions: {}
+
 on:
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
@@ -9,7 +13,6 @@ on:
   pull_request:
     branches:
       - main
-  merge_group:
 
 # ensure that the workflow is only triggered once per PR,  subsequent pushes to the PR will cancel
 # and restart the workflow. See https://docs.github.com/en/actions/using-jobs/using-concurrency
@@ -17,144 +20,276 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
 
-env:
-  # don't install husky hooks during CI as they are only needed for for pre-push
-  CARGO_HUSKY_DONT_INSTALL_HOOKS: true
-
-# lint, clippy and coveraget jobs are intentionally early in the workflow to catch simple
-# formatting, typos, and missing tests as early as possible. This allows us to fix these and
-# resubmit the PR without having to wait for the comprehensive matrix of tests to complete.
+# lint, clippy and coverage jobs are intentionally early in the workflow to catch simple formatting,
+# typos, and missing tests as early as possible. This allows us to fix these and resubmit the PR
+# without having to wait for the comprehensive matrix of tests to complete.
 jobs:
-  lint:
+  # Lint the formatting of the codebase.
+  lint-formatting:
+    name: Check Formatting
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Install Rust nightly
-        uses: dtolnay/rust-toolchain@nightly
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
         with:
+          persist-credentials: false
+      - uses: dtolnay/rust-toolchain@f7ccc83f9ed1e5b9c81d8a67d7ad1a747e22a561 # master
+        with:
+          toolchain: nightly
           components: rustfmt
-      - name: Install cargo-make
-        uses: taiki-e/install-action@cargo-make
-      - name: Cache Cargo dependencies
-        uses: Swatinem/rust-cache@v2
-      - name: Check formatting
-        run: cargo make lint-format
-      - name: Check documentation
-        run: cargo make lint-docs
-      - name: Check typos
-        uses: crate-ci/typos@master
-      - name: Lint dependencies
-        uses: EmbarkStudios/cargo-deny-action@v1
+      - uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
+      - uses: taiki-e/install-action@4c6723ec9c638cccae824b8957c5085b695c8085 # v2
+        with:
+          tool: taplo-cli
+      - run: cargo xtask format --check
 
-  clippy:
+  # Check for typos in the codebase.
+  # See <https://github.com/crate-ci/typos/>
+  lint-typos:
+    name: Check Typos
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
         with:
+          persist-credentials: false
+      - uses: crate-ci/typos@2d0ce569feab1f8752f1dde43cc2f2aa53236e06 # master
+
+  # Check for any disallowed dependencies in the codebase due to license / security issues.
+  # See <https://github.com/EmbarkStudios/cargo-deny>
+  cargo-deny:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        checks:
+          - advisories
+          - bans licenses sources
+    # Prevent sudden announcement of a new advisory from failing ci:
+    continue-on-error: ${{ matrix.checks == 'advisories' }}
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+      - uses: EmbarkStudios/cargo-deny-action@76cd80eb775d7bbbd2d80292136d74d39e1b4918 # v2
+        with:
+          rust-toolchain: stable
+          log-level: info
+          arguments: --all-features --exclude-unpublished
+          command: check ${{ matrix.checks }}
+
+  # Check for any unused dependencies in the codebase.
+  # See <https://github.com/bnjbvr/cargo-machete/>
+  cargo-machete:
+    name: Check Unused Dependencies
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+      - uses: bnjbvr/cargo-machete@7959c845782fed02ee69303126d4a12d64f1db18 # v0.9.1
+
+  # Run cargo clippy.
+  #
+  # We check for clippy warnings on beta, but these are not hard failures. They should often be
+  # fixed to prevent clippy failing on the next stable release, but don't block PRs on them unless
+  # they are introduced by the PR.
+  lint-clippy:
+    name: Check Clippy
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        toolchain: ["stable", "beta"]
+    continue-on-error: ${{ matrix.toolchain == 'beta' }}
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+      - uses: dtolnay/rust-toolchain@f7ccc83f9ed1e5b9c81d8a67d7ad1a747e22a561 # master
+        with:
+          toolchain: ${{ matrix.toolchain }}
           components: clippy
-      - name: Install cargo-make
-        uses: taiki-e/install-action@cargo-make
-      - name: Cache Cargo dependencies
-        uses: Swatinem/rust-cache@v2
-      - name: Run cargo make clippy-all
-        run: cargo make clippy
+      - uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
+      - run: cargo xtask clippy
+        env:
+          RUSTUP_TOOLCHAIN: ${{ matrix.toolchain }}
 
-  coverage:
+  # Run markdownlint on all markdown files in the repository.
+  lint-markdown:
+    name: Check Markdown
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
         with:
+          persist-credentials: false
+      - uses: DavidAnson/markdownlint-cli2-action@07035fd053f7be764496c0f8d8f9f41f98305101 # v21
+        with:
+          globs: |
+            '**/*.md'
+            '!target'
+
+  # Run cargo coverage. This will generate a coverage report and upload it to codecov.
+  # <https://app.codecov.io/gh/ratatui/ratatui>
+  coverage:
+    name: Coverage Report
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+      - uses: dtolnay/rust-toolchain@f7ccc83f9ed1e5b9c81d8a67d7ad1a747e22a561 # master
+        with:
+          toolchain: stable
           components: llvm-tools
-      - name: Install cargo-llvm-cov and cargo-make
-        uses: taiki-e/install-action@v2
+      - uses: taiki-e/install-action@4c6723ec9c638cccae824b8957c5085b695c8085 # v2
         with:
-          tool: cargo-llvm-cov,cargo-make
-      - name: Cache Cargo dependencies
-        uses: Swatinem/rust-cache@v2
-      - name: Generate coverage
-        run: cargo make coverage
-      - name: Upload to codecov.io
-        uses: codecov/codecov-action@v4
+          tool: cargo-llvm-cov
+      - uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
+      - run: cargo xtask coverage
+      - uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           fail_ci_if_error: true
 
+  # Run cargo check. This is a fast way to catch any obvious errors in the code.
   check:
+    name: Check ${{ matrix.os }} ${{ matrix.toolchain }}
     strategy:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        toolchain: ["1.74.0", "stable"]
+        toolchain: ["1.86.0", "stable"]
     runs-on: ${{ matrix.os }}
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Install Rust {{ matrix.toolchain }}
-        uses: dtolnay/rust-toolchain@master
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+      - uses: dtolnay/rust-toolchain@f7ccc83f9ed1e5b9c81d8a67d7ad1a747e22a561 # master
         with:
           toolchain: ${{ matrix.toolchain }}
-      - name: Install cargo-make
-        uses: taiki-e/install-action@cargo-make
-      - name: Cache Cargo dependencies
-        uses: Swatinem/rust-cache@v2
-      - name: Run cargo make check
-        run: cargo make check
+      - uses: taiki-e/install-action@4c6723ec9c638cccae824b8957c5085b695c8085 # v2
+        with:
+          tool: cargo-hack
+      - uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
+      - run: cargo xtask check --all-features
         env:
-          RUST_BACKTRACE: full
+          RUSTUP_TOOLCHAIN: ${{ matrix.toolchain }}
 
-  test-doc:
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
+  build-no-std:
+    name: Build No-Std
+    runs-on: ubuntu-latest
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-      - name: Install cargo-make
-        uses: taiki-e/install-action@cargo-make
-      - name: Cache Cargo dependencies
-        uses: Swatinem/rust-cache@v2
-      - name: Test docs
-        run: cargo make test-doc
-        env:
-          RUST_BACKTRACE: full
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+      - uses: dtolnay/rust-toolchain@f7ccc83f9ed1e5b9c81d8a67d7ad1a747e22a561 # master
+        with:
+          toolchain: stable
+          targets: x86_64-unknown-none
+      - uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
+      # This makes it easier to debug the exact versions of the dependencies
+      - run: cargo tree --target x86_64-unknown-none -p ratatui-core
+      - run: cargo tree --target x86_64-unknown-none -p ratatui-widgets
+      - run: cargo tree --target x86_64-unknown-none -p ratatui-macros
+      - run: cargo tree --target x86_64-unknown-none -p ratatui --no-default-features
+      - run: cargo build --target x86_64-unknown-none -p ratatui-core
+      - run: cargo build --target x86_64-unknown-none -p ratatui-widgets
+      - run: cargo build --target x86_64-unknown-none -p ratatui-macros
+      - run: cargo build --target x86_64-unknown-none -p ratatui --no-default-features
 
-  test:
+  # Check if README.md is up-to-date with the crate's documentation.
+  check-readme:
+    name: Check README
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+      - uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
+      - uses: taiki-e/install-action@4c6723ec9c638cccae824b8957c5085b695c8085 # v2
+        with:
+          tool: cargo-rdme
+      - run: cargo xtask readme --check
+
+  # Run cargo rustdoc with the same options that would be used by docs.rs, taking into account the
+  # package.metadata.docs.rs configured in Cargo.toml. https://github.com/dtolnay/cargo-docs-rs
+  lint-docs:
+    name: Check Docs
+    runs-on: ubuntu-latest
+    env:
+      RUSTDOCFLAGS: -Dwarnings
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+      - uses: dtolnay/rust-toolchain@f7ccc83f9ed1e5b9c81d8a67d7ad1a747e22a561 # master
+        with:
+          toolchain: nightly
+      - uses: dtolnay/install@74f735cdf643820234e37ae1c4089a08fd266d8a # master
+        with:
+          crate: cargo-docs-rs
+      - uses: taiki-e/install-action@4c6723ec9c638cccae824b8957c5085b695c8085 # v2
+        with:
+          tool: cargo-hack
+      - uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
+      - run: cargo xtask docs
+
+  # Run cargo test on the documentation of the crate. This will catch any code examples that don't
+  # compile, or any other issues in the documentation.
+  test-docs:
+    name: Test Docs
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+      - uses: dtolnay/rust-toolchain@f7ccc83f9ed1e5b9c81d8a67d7ad1a747e22a561 # master
+        with:
+          toolchain: stable
+      - uses: taiki-e/install-action@4c6723ec9c638cccae824b8957c5085b695c8085 # v2
+        with:
+          tool: cargo-hack
+      - uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
+      - run: cargo xtask test-docs
+
+  # Run cargo test on the libraries of the crate.
+  test-libs:
+    name: Test Libs ${{ matrix.toolchain }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        toolchain: ["1.86.0", "stable"]
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+      - uses: dtolnay/rust-toolchain@f7ccc83f9ed1e5b9c81d8a67d7ad1a747e22a561 # master
+        with:
+          toolchain: stable
+      - uses: taiki-e/install-action@4c6723ec9c638cccae824b8957c5085b695c8085 # v2
+        with:
+          tool: cargo-hack
+      - uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
+      - run: cargo xtask test-libs
+
+  # Run cargo test on all the backends.
+  test-backends:
+    name: Test ${{matrix.backend}} on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        toolchain: ["1.74.0", "stable"]
         backend: [crossterm, termion, termwiz]
         exclude:
           # termion is not supported on windows
           - os: windows-latest
             backend: termion
-    runs-on: ${{ matrix.os }}
     steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Install Rust ${{ matrix.toolchain }}}
-        uses: dtolnay/rust-toolchain@master
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
         with:
-          toolchain: ${{ matrix.toolchain }}
-      - name: Install cargo-make
-        uses: taiki-e/install-action@cargo-make
-      - name: Install cargo-nextest
-        uses: taiki-e/install-action@nextest
-      - name: Cache Cargo dependencies
-        uses: Swatinem/rust-cache@v2
-      - name: Test ${{ matrix.backend }}
-        run: cargo make test-backend ${{ matrix.backend }}
-        env:
-          RUST_BACKTRACE: full
+          persist-credentials: false
+      - uses: dtolnay/rust-toolchain@f7ccc83f9ed1e5b9c81d8a67d7ad1a747e22a561 # master
+        with:
+          toolchain: stable
+      - uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2
+      - run: cargo xtask test-backend ${{ matrix.backend }}

.github/workflows/release-plz.yml

@@ -0,0 +1,71 @@
+name: Release-plz
+
+# Set the permissions of the github token to the minimum and only enable what is needed
+# See https://docs.github.com/en/actions/security-guides/automatic-token-authentication#permissions
+permissions: {}
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  # Release unpublished packages.
+  release-plz-release:
+    name: Release-plz release
+    environment: release
+    permissions:
+      pull-requests: write
+      contents: write
+      id-token: write
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'ratatui' }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@f7ccc83f9ed1e5b9c81d8a67d7ad1a747e22a561 # master
+        with:
+          toolchain: stable
+      - uses: rust-lang/crates-io-auth-action@b7e9a28eded4986ec6b1fa40eeee8f8f165559ec # v1
+        id: auth
+      - name: Run release-plz
+        uses: release-plz/action@487eb7b5c085a664d5c5ca05f4159bd9b591182a # v0.5
+        with:
+          command: release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ steps.auth.outputs.token }}
+
+  # Create a PR with the new versions and changelog, preparing the next release.
+  release-plz-pr:
+    name: Release-plz PR
+    permissions:
+      pull-requests: write
+      contents: write
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'ratatui' }}
+    concurrency:
+      group: release-plz-${{ github.ref }}
+      cancel-in-progress: false
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@f7ccc83f9ed1e5b9c81d8a67d7ad1a747e22a561 # master
+        with:
+          toolchain: stable
+      - name: Run release-plz
+        uses: release-plz/action@487eb7b5c085a664d5c5ca05f4159bd9b591182a # v0.5
+        with:
+          command: release-pr
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_TOKEN }}

.github/workflows/zizmor.yml

@@ -0,0 +1,26 @@
+name: GitHub Actions Security Analysis with zizmor 🌈
+
+# docs https://docs.zizmor.sh/integrations/#github-actions
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["**"]
+
+permissions: {}
+
+jobs:
+  zizmor:
+    name: Run zizmor 🌈
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+
+      - name: Run zizmor 🌈
+        uses: zizmorcore/zizmor-action@e639db99335bc9038abc0e066dfcd72e23d26fb4 # v0.3.0

.gitignore

@@ -1,6 +1,6 @@
 target
-Cargo.lock
 *.log
 *.rs.rustfmt
 .gdb_history
 .idea/
+.env

.taplo.toml

@@ -0,0 +1,12 @@
+include = ["**/*.toml"]
+
+[formatting]
+column_width = 100
+reorder_keys = false
+
+[[rule]]
+include = ["**/Cargo.toml"]
+keys = ["dependencies", "dev-dependencies", "build-dependencies", "workspace.dependencies"]
+
+[rule.formatting]
+reorder_keys = true

ARCHITECTURE.md

@@ -0,0 +1,203 @@
+# Ratatui Architecture
+
+This document provides a comprehensive overview of Ratatui's architecture and crate
+organization, introduced in version 0.30.0.
+
+## Overview
+
+Starting with Ratatui 0.30.0, the project was reorganized from a single monolithic crate into
+a modular workspace consisting of multiple specialized crates. This architectural decision was
+made to improve modularity, reduce compilation times, enable more flexible dependency
+management, and provide better API stability for third-party widget libraries.
+
+## Crate Organization
+
+The Ratatui project is now organized as a Cargo workspace containing the following crates:
+
+### Core Crates
+
+#### `ratatui` (Main Crate)
+
+- **Purpose**: The main entry point that most applications should use
+- **Contents**: Re-exports everything from other crates for convenience, plus experimental features
+- **Target Users**: Application developers building terminal UIs
+- **Key Features**:
+  - Complete widget ecosystem
+  - Backend implementations
+  - Layout system
+  - Terminal management
+  - Experimental `WidgetRef` and `StatefulWidgetRef` traits
+
+#### `ratatui-core`
+
+- **Purpose**: Foundational types and traits for the Ratatui ecosystem
+- **Contents**: Core widget traits, text types, buffer, layout, style, and symbols
+- **Target Users**: Widget library authors, minimalist projects
+- **Key Features**:
+  - `Widget` and `StatefulWidget` traits
+  - Text rendering (`Text`, `Line`, `Span`)
+  - Buffer management
+  - Layout system
+  - Style and color definitions
+  - Symbol collections
+
+#### `ratatui-widgets`
+
+- **Purpose**: Built-in widget implementations
+- **Contents**: All standard widgets like `Block`, `Paragraph`, `List`, `Chart`, etc.
+- **Target Users**: Applications needing standard widgets, widget library authors
+- **Key Features**:
+  - Complete set of built-in widgets
+  - Optimized implementations
+  - Comprehensive documentation and examples
+
+### Backend Crates
+
+#### `ratatui-crossterm`
+
+- **Purpose**: Crossterm backend implementation
+- **Contents**: Cross-platform terminal backend using the `crossterm` crate
+- **Target Users**: Applications targeting multiple platforms
+
+#### `ratatui-termion`
+
+- **Purpose**: Termion backend implementation
+- **Contents**: Unix-specific terminal backend using the `termion` crate
+- **Target Users**: Unix-specific applications requiring low-level control
+
+#### `ratatui-termwiz`
+
+- **Purpose**: Termwiz backend implementation
+- **Contents**: Terminal backend using the `termwiz` crate
+- **Target Users**: Applications needing advanced terminal features
+
+### Utility Crates
+
+#### `ratatui-macros`
+
+- **Purpose**: Declarative macros for common patterns and boilerplate reduction
+- **Contents**: Macros for common patterns and boilerplate reduction
+- **Target Users**: Applications and libraries wanting macro support
+
+## Dependency Relationships
+
+```text
+ratatui
+├── ratatui-core
+├── ratatui-widgets → ratatui-core
+├── ratatui-crossterm → ratatui-core
+├── ratatui-termion → ratatui-core
+├── ratatui-termwiz → ratatui-core
+└── ratatui-macros
+```
+
+### Key Dependencies
+
+- **ratatui-core**: Foundation for all other crates
+- **ratatui-widgets**: Depends on `ratatui-core` for widget traits and types
+- **Backend crates**: Each depends on `ratatui-core` for backend traits and types
+- **ratatui**: Depends on all other crates and re-exports their public APIs
+
+## Design Principles
+
+### Stability and Compatibility
+
+The modular architecture provides different levels of API stability:
+
+- **ratatui-core**: Designed for maximum stability to minimize breaking changes for widget
+  libraries
+- **ratatui-widgets**: Focused on widget implementations with moderate stability requirements
+- **Backend crates**: Isolated from core changes, allowing backend-specific updates
+- **ratatui**: Main crate that can evolve more freely while maintaining backward compatibility
+  through re-exports
+
+### Compilation Performance
+
+The split architecture enables:
+
+- **Reduced compilation times**: Widget libraries only need to compile core types
+- **Parallel compilation**: Different crates can be compiled in parallel
+- **Selective compilation**: Applications can exclude unused backends or widgets
+
+### Ecosystem Benefits
+
+- **Widget Library Authors**: Can depend on stable `ratatui-core` without frequent updates
+- **Application Developers**: Can use the convenient `ratatui` crate with everything included
+- **Minimalist Projects**: Can use only `ratatui-core` for lightweight applications
+
+## Migration Guide
+
+### For Application Developers
+
+Most applications should continue using the main `ratatui` crate with minimal changes:
+
+```rust
+// No changes needed - everything is re-exported
+use ratatui::{
+    widgets::{Block, Paragraph},
+    layout::{Layout, Constraint},
+    Terminal,
+};
+```
+
+### For Widget Library Authors
+
+Consider migrating to `ratatui-core` for better stability:
+
+```rust
+// Before (0.29.x and earlier)
+use ratatui::{
+    widgets::{Widget, StatefulWidget},
+    buffer::Buffer,
+    layout::Rect,
+};
+
+// After (0.30.0+)
+use ratatui_core::{
+    widgets::{Widget, StatefulWidget},
+    buffer::Buffer,
+    layout::Rect,
+};
+```
+
+### Backwards Compatibility
+
+All existing code using the `ratatui` crate will continue to work unchanged, as the main crate
+re-exports all public APIs from the specialized crates.
+
+## Future Considerations
+
+### Potential Enhancements
+
+- **Widget-specific crates**: Further split widgets into individual crates for even more
+  granular dependencies
+- **Plugin system**: Enable dynamic widget loading and third-party widget ecosystems
+- **Feature flags**: More granular feature flags for compile-time customization
+
+### Version Synchronization
+
+Currently, all crates are versioned together for simplicity. Future versions may adopt
+independent versioning once the API stabilizes further.
+
+## Related Issues and PRs
+
+This architecture was developed through extensive discussion and implementation across multiple
+PRs:
+
+- [Issue #1388](https://github.com/ratatui/ratatui/issues/1388): Original RFC for modularization
+- [PR #1459](https://github.com/ratatui/ratatui/pull/1459): Move ratatui crate into workspace
+  folder
+- [PR #1460](https://github.com/ratatui/ratatui/pull/1460): Move core types to ratatui-core
+- [PR #1474](https://github.com/ratatui/ratatui/pull/1474): Move widgets into ratatui-widgets
+  crate
+
+## Contributing
+
+When contributing to the Ratatui project, please consider:
+
+- **Core changes**: Submit PRs against `ratatui-core` for fundamental improvements
+- **Widget changes**: Submit PRs against `ratatui-widgets` for widget-specific improvements
+- **Backend changes**: Submit PRs against the appropriate backend crate
+- **Integration changes**: Submit PRs against the main `ratatui` crate
+
+See the [CONTRIBUTING.md](CONTRIBUTING.md) guide for more details on the contribution process.

BREAKING-CHANGES.md

@@ -4,12 +4,60 @@ This document contains a list of breaking changes in each version and some notes
 between versions. It is compiled manually from the commit history and changelog. We also tag PRs on
 GitHub with a [breaking change] label.
 
-[breaking change]: (https://github.com/ratatui-org/ratatui/issues?q=label%3A%22breaking+change%22)
+[breaking change]: (https://github.com/ratatui/ratatui/issues?q=label%3A%22breaking+change%22)
 
 ## Summary
 
 This is a quick summary of the sections below:
 
+- [v0.30.1](#v0301)
+  - Adding `AsRef` impls for widgets may affect type inference in rare cases
+- [v0.30.0](#v0300)
+  - `Flex::SpaceAround` now mirrors flexbox: space between items is twice the size of the outer gaps
+    are twice the size of first and last elements
+  - `block::Title` no longer exists
+  - The `From` impls for backend types are now replaced with more specific traits
+  - `FrameExt` trait for `unstable-widget-ref` feature
+  - `List::highlight_symbol` now accepts `Into<Line>` instead of `&str`
+  - 'layout::Alignment' is renamed to 'layout::HorizontalAlignment'
+  - MSRV is now 1.86.0
+  - `Backend` now requires an associated `Error` type and `clear_region` method
+  - `TestBackend` now uses `core::convert::Infallible` for error handling instead of `std::io::Error`
+  - Disabling `default-features` will now disable layout cache, which can have a negative impact on performance
+  - `Layout::init_cache` and `Layout::DEFAULT_CACHE_SIZE` are now only available if `layout-cache`
+    feature is enabled
+  - Disabling `default-features` suppresses the error message if `show_cursor()` fails when dropping
+    `Terminal`
+  - Support a broader range for `unicode-width` version
+  - `Marker` is now non-exhaustive
+  - `symbols::braille::BLANK` and `symbols::braille::DOTS` have been removed in favor of an ordered
+    array of all Braille characters
+- [v0.29.0](#v0290)
+  - `Sparkline::data` takes `IntoIterator<Item = SparklineBar>` instead of `&[u64]` and is no longer
+    const
+  - Removed public fields from `Rect` iterators
+  - `Line` now implements `From<Cow<str>`
+  - `Table::highlight_style` is now `Table::row_highlight_style`
+  - `Tabs::select` now accepts `Into<Option<usize>>`
+  - `Color::from_hsl` is now behind the `palette` feature
+- [v0.28.0](#v0280)
+  - `Backend::size` returns `Size` instead of `Rect`
+  - `Backend` trait migrates to `get/set_cursor_position`
+  - Ratatui now requires Crossterm 0.28.0
+  - `Axis::labels` now accepts `IntoIterator<Into<Line>>`
+  - `Layout::init_cache` no longer returns bool and takes a `NonZeroUsize` instead of `usize`
+  - `ratatui::terminal` module is now private
+  - `ToText` no longer has a lifetime
+  - `Frame::size` is deprecated and renamed to `Frame::area`
+- [v0.27.0](#v0270)
+  - List no clamps the selected index to list
+  - Prelude items added / removed
+  - 'termion' updated to 4.0
+  - `Rect::inner` takes `Margin` directly instead of reference
+  - `Buffer::filled` takes `Cell` directly instead of reference
+  - `Stylize::bg()` now accepts `Into<Color>`
+  - Removed deprecated `List::start_corner`
+  - `LineGauge::gauge_style` is deprecated
 - [v0.26.0](#v0260)
   - `Flex::Start` is the new default flex mode for `Layout`
   - `patch_style` & `reset_style` now consume and return `Self`
@@ -47,11 +95,650 @@ This is a quick summary of the sections below:
   - MSRV is now 1.63.0
   - `List` no longer ignores empty strings
 
-## [v0.26.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.26.0)
+## [v0.30.1](https://github.com/ratatui/ratatui/releases/tag/ratatui-v0.30.1)
+
+### Adding `AsRef` impls for widgets may affect type inference ([#2297])
+
+[#2297]: https://github.com/ratatui/ratatui/pull/2297
+
+Adding `AsRef<Self>` for built-in widgets can change type inference outcomes in rare cases where
+`AsRef` is part of a trait bound, and can also conflict with downstream blanket or manual `AsRef`
+impls for widget types. If you hit new ambiguity errors, add explicit type annotations or specify
+the concrete widget type to guide inference, and remove any redundant `AsRef` impls.
+
+## [v0.30.0](https://github.com/ratatui/ratatui/releases/tag/ratatui-v0.30.0)
+
+### `Marker` is now non-exhaustive ([#2236])
+
+[#2236]: https://github.com/ratatui/ratatui/pull/2236
+
+The `Marker` enum is now marked as `#[non_exhaustive]`, if you were matching on `Marker` exhaustively,
+you will need to add a wildcard arm:
+
+```diff
+  match marker {
+      Marker::Dot => { /* ... */ }
+      Marker::Block => { /* ... */ }
+      Marker::Bar => { /* ... */ }
+      Marker::Braille => { /* ... */ }
+      Marker::HalfBlock => { /* ... */ }
++     _ => { /* ... */ }
+  }
+```
+
+### `Flex::SpaceAround` now mirrors flexbox: space between items is twice the size of the outer gaps ([#1952])
+
+[#1952]: https://github.com/ratatui/ratatui/pull/1952
+
+The old `Flex::SpaceAround` behavior has been changed to distribute space evenly around each
+element, with the middle spacers being twice the size of the first and last one. The old
+behavior can be achieved by using `Flex::SpaceEvenly` instead.
+
+```diff
+- let rects = Layout::horizontal([Length(1), Length(2)]).flex(Flex::SpaceAround).split(area);
++ let rects = Layout::horizontal([Length(1), Length(2)]).flex(Flex::SpaceEvenly).split(area);
+```
+
+### `block::Title` no longer exists ([#1926])
+
+[#1926]: https://github.com/ratatui/ratatui/pull/1926
+
+The title alignment is better expressed in the `Line` as this fits more coherently with the rest of
+the library.
+
+- `widgets::block` is no longer exported
+- `widgets::block::Title` no longer exists
+- `widgets::block::Position` is now `widgets::TitlePosition`
+- `Block::title()` now accepts `Into::<Line>` instead of `Into<Title>`
+- `BlockExt` is now exported at widgets::`BlockExt` instead of `widgets::block::BlockExt`
+
+```diff
+- use ratatui::widgets::{Block, block::{Title, Position}};
++ use ratatui::widgets::{Block, TitlePosition};
+
+let block = Block::default()
+-    .title(Title::from("Hello"))
+-    .title(Title::from("Hello").position(Position::Bottom).alignment(Alignment::Center))
+-    .title_position(Position::Bottom);
++    .title(Line::from("Hello"))
++    .title_bottom(Line::from("Hello").centered());
++    .title_position(TitlePosition::Bottom);
+
+- use ratatui::widgets::block::BlockExt;
++ use ratatui::widgets::BlockExt;
+
+struct MyWidget {
+    block: Option<Block>,
+}
+
+impl Widget for &MyWidget {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        self.block.as_ref().render(area, buf);
+        let area = self.block.inner_if_some();
+        // ...
+    }
+}
+```
+
+### `Style` no longer implements `Styled` ([#1572])
+
+[#1572]: https://github.com/ratatui/ratatui/pull/1572
+
+Any calls to methods implemented by the blanket implementation of `Stylize` are now defined directly
+on `Style`. Remove the `Stylize` import if it is no longer used by your code.
+
+```diff
+- use ratatui::style::Stylize;
+
+let style = Style::new().red();
+```
+
+The `reset()` method does not have a direct replacement, as it clashes with the existing `reset()`
+method. Use the `Style::reset()` method instead.
+
+```diff
+- some_style.reset();
++ Style::reset();
+```
+
+### Disabling `default-features` suppresses the error message if `show_cursor()` fails when dropping `Terminal` ([#1794])
+
+[#1794]: https://github.com/ratatui/ratatui/pull/1794
+
+Since disabling `default-features` disables `std`, printing to stderr is not possible. It is
+recommended to re-enable `std` when not using Ratatui in `no_std` environment.
+
+### `Layout::init_cache` and `Layout::DEFAULT_CACHE_SIZE` are now only available if `layout-cache` feature is enabled ([#1795])
+
+[#1795]: https://github.com/ratatui/ratatui/pull/1795
+
+Previously, `Layout::init_cache` and `Layout::DEFAULT_CACHE_SIZE` were available independently of
+enabled feature flags.
+
+### Disabling `default-features` will now disable layout cache, which can have a negative impact on performance ([#1795])
+
+Layout cache is now opt-in in `ratatui-core` and enabled by default in `ratatui`. If app doesn't
+make use of `no_std`-compatibility, and disables `default-feature`, it is recommended to explicitly
+re-enable layout cache. Not doing so may impact performance.
+
+```diff
+- ratatui = { version = "0.29.0", default-features = false }
++ ratatui = { version = "0.30.0", default-features = false, features = ["layout-cache"] }
+```
+
+### `TestBackend` now uses `core::convert::Infallible` for error handling instead of `std::io::Error` ([#1823])
+
+[#1823]: https://github.com/ratatui/ratatui/pull/1823
+
+Since `TestBackend` never fails, it now uses `Infallible` as associated `Error`. This may require
+changes in test cases that use `TestBackend`.
+
+### `Backend` now requires an associated `Error` type and `clear_region` method ([#1778])
+
+[#1778]: https://github.com/ratatui/ratatui/pull/1778
+
+Custom `Backend` implementations must now define an associated `Error` type for method `Result`s
+and implement the `clear_region` method, which no longer has a default implementation.
+
+This change was made to provide greater flexibility for custom backends, particularly to remove the
+explicit dependency on `std::io` for backends that want to support `no_std` targets.
+
+If your app or library uses the `Backend` trait directly - for example, by providing a generic
+implementation for many backends - you may need to update the referenced error type.
+
+```diff
+- fn run<B: Backend>(mut terminal: Terminal<B>) -> io::Result<()> {
++ fn run<B: Backend>(mut terminal: Terminal<B>) -> Result<(), B::Error> {
+```
+
+Alternatively, you can explicitly require the associated error to be `std::io::Error`. This approach
+may require fewer changes in user code but is generally not recommended, as it limits compatibility
+with third-party backends. Additionally, the error type used by built-in backends may or may not
+change in the future, making this approach less future-proof compared to the previous one.
+
+```diff
+- fn run<B: Backend>(mut terminal: Terminal<B>) -> io::Result<()> {
++ fn run<B: Backend<Error = io::Error>>(mut terminal: Terminal<B>) -> io::Result<()> {
+```
+
+If your application uses a concrete backend implementation, prefer specifying it explicitly
+instead.
+
+```diff
+- fn run<B: Backend>(mut terminal: Terminal<B>) -> io::Result<()> {
++ fn run(mut terminal: DefaultTerminal) -> io::Result<()> {
+```
+
+### MSRV is now 1.86.0 ([#2230])
+
+[#2230]: https://github.com/ratatui/ratatui/pull/2230
+
+The minimum supported Rust version (MSRV) is now 1.86.0.
+
+### `layout::Alignment` is renamed to `layout::HorizontalAlignment` ([#1735])
+
+[#1735]: https://github.com/ratatui/ratatui/pull/1691
+
+The `Alignment` enum has been renamed to `HorizontalAlignment` to better reflect its purpose. A type
+alias has been added to maintain backwards compatibility, however there are some cases where type
+aliases are not enough to maintain backwards compatibility. E.g. when using glob imports to import
+all the enum variants.
+
+We don't expect to remove or deprecate the type alias in the near future, but it is recommended to
+update your imports to use the new name.
+
+```diff
+- use ratatui::layout::Alignment;
++ use ratatui::layout::HorizontalAlignment;
+
+- use Alignment::*;
++ use HorizontalAlignment::*;
+```
+
+### `List::highlight_symbol` accepts `Into<Line>` ([#1595])
+
+[#1595]: https://github.com/ratatui/ratatui/pull/1595
+
+Previously `List::highlight_symbol` accepted `&str`. Any code that uses conversion methods will need
+to be rewritten. Since `Into::into` is not const, this function cannot be called in const context.
+
+### `FrameExt` trait for `unstable-widget-ref` feature ([#1530])
+
+[#1530]: https://github.com/ratatui/ratatui/pull/1530
+
+To call `Frame::render_widget_ref()` or `Frame::render_stateful_widget_ref()` you now need to:
+
+1. Import the `FrameExt` trait from `ratatui::widgets`.
+2. Enable the `unstable-widget-ref` feature.
+
+For example:
+
+```rust
+use ratatui::{
+    layout::Rect,
+    widgets::{Block, FrameExt},
+};
+
+let block = Block::new();
+let area = Rect::new(0, 0, 5, 5);
+frame.render_widget_ref(&block, area);
+```
+
+### `WidgetRef` no longer has a blanket implementation of Widget
+
+Previously there was a blanket implementation of Widget for WidgetRef. This has been reversed to
+instead be a blanket implementation of WidgetRef for all &W where W: Widget. Any widgets that
+previously implemented WidgetRef directly should now instead implement Widget for a reference to the
+type.
+
+```diff
+-impl WidgetRef for Foo {
+-    fn render_ref(&self, area: Rect, buf: &mut Buffer)
++impl Widget for &Foo {
++    fn render(self, area: Rect, buf: &mut Buffer)
+}
+```
+
+### The `From` impls for backend types are now replaced with more specific traits [#1464]
+
+[#1464]: https://github.com/ratatui/ratatui/pull/1464
+
+Crossterm gains `ratatui::backend::crossterm::{FromCrossterm, IntoCrossterm}`
+Termwiz gains `ratatui::backend::termwiz::{FromTermwiz, IntoTermwiz}`
+
+This is necessary in order to avoid the orphan rule when implementing `From` for crossterm types
+once the crossterm types are moved to a separate crate.
+
+```diff
++ use ratatui::backend::crossterm::{FromCrossterm, IntoCrossterm};
+
+let crossterm_color = crossterm::style::Color::Black;
+- let ratatui_color = crossterm_color.into();
+- let ratatui_color = ratatui::style::Color::from(crossterm_color);
++ let ratatui_color = ratatui::style::Color::from_crossterm(crossterm_color);
+- let crossterm_color = ratatui_color.into();
+- let crossterm_color = crossterm::style::Color::from(ratatui_color);
++ let crossterm_color = ratatui_color.into_crossterm();
+
+let crossterm_attribute = crossterm::style::types::Attribute::Bold;
+- let ratatui_modifier = crossterm_attribute.into();
+- let ratatui_modifier = ratatui::style::Modifier::from(crossterm_attribute);
++ let ratatui_modifier = ratatui::style::Modifier::from_crossterm(crossterm_attribute);
+- let crossterm_attribute = ratatui_modifier.into();
+- let crossterm_attribute = crossterm::style::types::Attribute::from(ratatui_modifier);
++ let crossterm_attribute = ratatui_modifier.into_crossterm();
+```
+
+Similar conversions for `ContentStyle` -> `Style` and `Attributes` -> `Modifier` exist for
+Crossterm and the various Termion and Termwiz types as well.
+
+### `Bar::label()` and `BarGroup::label()` now accepts `Into<Line<'a>>`. ([#1471])
+
+[#1471]: https://github.com/ratatui/ratatui/pull/1471
+
+Previously `Bar::label()` and `BarGroup::label()` accepted `Line<'a>`, but they now accepts `Into<Line<'a>>`.
+
+for `Bar::label()`:
+
+```diff
+- Bar::default().label("foo".into());
++ Bar::default().label("foo");
+```
+
+for `BarGroup::label()`:
+
+```diff
+- BarGroup::default().label("bar".into());
++ BarGroup::default().label("bar");
+```
+
+### `Bar::text_value` now accepts `Into<String>` ([#1471])
+
+Previously `Bar::text_value` accepted `String`, but now it accepts `Into<String>`.
+
+for `Bar::text_value()`:
+
+```diff
+- Bar::default().text_value("foobar".into());
++ Bar::default().text_value("foobar");
+```
+
+### `termwiz` is upgraded to 0.23.0 ([#1682])
+
+[#1682]: https://github.com/ratatui/ratatui/pull/1682
+
+The `termwiz` backend is upgraded from 0.22.0 to 0.23.0.
+
+This release has a few fixes for hyperlinks and input handling, plus some dependency updates.
+See the [commits](https://github.com/wezterm/wezterm/commits/main/termwiz) for more details.
+
+### Support a broader range for `unicode-width` version ([#1999])
+
+[#1999]: https://github.com/ratatui/ratatui/pull/1999
+
+Ratatui's dependency on `unicode-width`, previously pinned to 0.2.0, has
+expanded to allow version 0.2.1. This comes with 2 behavior changes described in
+[unicode-width#61] and [unicode-width#74].
+
+[unicode-width#61]: https://github.com/unicode-rs/unicode-width/pull/61
+[unicode-width#74]: https://github.com/unicode-rs/unicode-width/pull/74
+
+## [v0.29.0](https://github.com/ratatui/ratatui/releases/tag/v0.29.0)
+
+### `Sparkline::data` takes `IntoIterator<Item = SparklineBar>` instead of `&[u64]` and is no longer const ([#1326])
+
+[#1326]: https://github.com/ratatui/ratatui/pull/1326
+
+The `Sparkline::data` method has been modified to accept `IntoIterator<Item = SparklineBar>`
+instead of `&[u64]`.
+
+`SparklineBar` is a struct that contains an `Option<u64>` value, which represents an possible
+_absent_ value, as distinct from a `0` value. This change allows the `Sparkline` to style
+data points differently, depending on whether they are present or absent.
+
+`SparklineBar` also contains an `Option<Style>` that will be used to apply a style the bar in
+addition to any other styling applied to the `Sparkline`.
+
+Several `From` implementations have been added to `SparklineBar` to support existing callers who
+provide `&[u64]` and other types that can be converted to `SparklineBar`, such as `Option<u64>`.
+
+If you encounter any type inference issues, you may need to provide an explicit type for the data
+passed to `Sparkline::data`. For example, if you are passing a single value, you may need to use
+`into()` to convert it to form that can be used as a `SparklineBar`:
+
+```diff
+let value = 1u8;
+- Sparkline::default().data(&[value.into()]);
++ Sparkline::default().data(&[u64::from(value)]);
+```
+
+As a consequence of this change, the `data` method is no longer a `const fn`.
+
+### `Color::from_hsl` is now behind the `palette` feature and accepts `palette::Hsl` ([#1418])
+
+[#1418]: https://github.com/ratatui/ratatui/pull/1418
+
+Previously `Color::from_hsl` accepted components as individual f64 parameters. It now accepts a
+single `palette::Hsl` value and is gated behind a `palette` feature flag.
+
+```diff
+- Color::from_hsl(360.0, 100.0, 100.0)
++ Color::from_hsl(Hsl::new(360.0, 100.0, 100.0))
+```
+
+### Removed public fields from `Rect` iterators ([#1358], [#1424])
+
+[#1358]: https://github.com/ratatui/ratatui/pull/1358
+[#1424]: https://github.com/ratatui/ratatui/pull/1424
+
+The `pub` modifier has been removed from fields on the `Columns`,`Rows`, and `Positions` iterators.
+These fields were not intended to be public and should not have been accessed directly.
+
+### `Rect::area()` now returns u32 instead of u16 ([#1378])
+
+[#1378]: https://github.com/ratatui/ratatui/pull/1378
+
+This is likely to impact anything which relies on `Rect::area` maxing out at u16::MAX. It can now
+return up to u16::MAX * u16::MAX (2^32 - 2^17 + 1).
+
+### `Line` now implements `From<Cow<str>` ([#1373])
+
+[#1373]: https://github.com/ratatui/ratatui/pull/1373
+
+As this adds an extra conversion, ambiguous inferred expressions may no longer compile.
+
+```rust
+// given:
+struct Foo { ... }
+impl From<Foo> for String { ... }
+impl From<Foo> for Cow<str> { ... }
+
+let foo = Foo { ... };
+let line = Line::from(foo); // now fails due to now ambiguous inferred type
+// replace with e.g.
+let line = Line::from(String::from(foo));
+```
+
+### `Tabs::select()` now accepts `Into<Option<usize>>` ([#1413])
+
+[#1413]: https://github.com/ratatui/ratatui/pull/1413
+
+Previously `Tabs::select()` accepted `usize`, but it now accepts `Into<Option<usize>>`. This breaks
+any code already using parameter type inference:
+
+```diff
+let selected = 1u8;
+- let tabs = Tabs::new(["A", "B"]).select(selected.into())
++ let tabs = Tabs::new(["A", "B"]).select(selected as usize)
+```
+
+### `Table::highlight_style` is now `Table::row_highlight_style` ([#1331])
+
+[#1331]: https://github.com/ratatui/ratatui/pull/1331
+
+The `Table::highlight_style` is now deprecated in favor of `Table::row_highlight_style`.
+
+Also, the serialized output of the `TableState` will now include the "selected_column" field.
+Software that manually parse the serialized the output (with anything other than the `Serialize`
+implementation on `TableState`) may have to be refactored if the "selected_column" field is not
+accounted for. This does not affect users who rely on the `Deserialize`, or `Serialize`
+implementation on the state.
+
+## [v0.28.0](https://github.com/ratatui/ratatui/releases/tag/v0.28.0)
+
+### `Backend::size` returns `Size` instead of `Rect` ([#1254])
+
+[#1254]: https://github.com/ratatui/ratatui/pull/1254
+
+The `Backend::size` method returns a `Size` instead of a `Rect`.
+There is no need for the position here as it was always 0,0.
+
+### `Backend` trait migrates to `get/set_cursor_position` ([#1284])
+
+[#1284]: https://github.com/ratatui/ratatui/pull/1284
+
+If you just use the types implementing the `Backend` trait, you will see deprecation hints but
+nothing is a breaking change for you.
+
+If you implement the Backend trait yourself, you need to update the implementation and add the
+`get/set_cursor_position` method. You can remove the `get/set_cursor` methods as they are deprecated
+and a default implementation for them exists.
+
+### Ratatui now requires Crossterm 0.28.0 ([#1278])
+
+[#1278]: https://github.com/ratatui/ratatui/pull/1278
+
+Crossterm is updated to version 0.28.0, which is a semver incompatible version with the previous
+version (0.27.0). Ratatui re-exports the version of crossterm that it is compatible with under
+`ratatui::crossterm`, which can be used to avoid incompatible versions in your dependency list.
+
+### `Axis::labels()` now accepts `IntoIterator<Into<Line>>` ([#1273] and [#1283])
+
+[#1273]: https://github.com/ratatui/ratatui/pull/1173
+[#1283]: https://github.com/ratatui/ratatui/pull/1283
+
+Previously Axis::labels accepted `Vec<Span>`. Any code that uses conversion methods that infer the
+type will need to be rewritten as the compiler cannot infer the correct type.
+
+```diff
+- Axis::default().labels(vec!["a".into(), "b".into()])
++ Axis::default().labels(["a", "b"])
+```
+
+### `Layout::init_cache` no longer returns bool and takes a `NonZeroUsize` instead of `usize` ([#1245])
+
+[#1245]: https://github.com/ratatui/ratatui/pull/1245
+
+```diff
+- let is_initialized = Layout::init_cache(100);
++ Layout::init_cache(NonZeroUsize::new(100).unwrap());
+```
+
+### `ratatui::terminal` module is now private ([#1160])
+
+[#1160]: https://github.com/ratatui/ratatui/pull/1160
+
+The `terminal` module is now private and can not be used directly. The types under this module are
+exported from the root of the crate. This reduces clashes with other modules in the backends that
+are also named terminal, and confusion about module exports for newer Rust users.
+
+```diff
+- use ratatui::terminal::{CompletedFrame, Frame, Terminal, TerminalOptions, ViewPort};
++ use ratatui::{CompletedFrame, Frame, Terminal, TerminalOptions, ViewPort};
+```
+
+### `ToText` no longer has a lifetime ([#1234])
+
+[#1234]: https://github.com/ratatui/ratatui/pull/1234
+
+This change simplifies the trait and makes it easier to implement.
+
+### `Frame::size` is deprecated and renamed to `Frame::area` ([#1293])
+
+[#1293]: https://github.com/ratatui/ratatui/pull/1293
+
+`Frame::size` is renamed to `Frame::area` as it's the more correct name.
+
+## [v0.27.0](https://github.com/ratatui/ratatui/releases/tag/v0.27.0)
+
+### List no clamps the selected index to list ([#1159])
+
+[#1149]: https://github.com/ratatui/ratatui/pull/1149
+
+The `List` widget now clamps the selected index to the bounds of the list when navigating with
+`first`, `last`, `previous`, and `next`, as well as when setting the index directly with `select`.
+
+Previously selecting an index past the end of the list would show treat the list as having a
+selection which was not visible. Now the last item in the list will be selected instead.
+
+### Prelude items added / removed ([#1149])
+
+The following items have been removed from the prelude:
+
+- `style::Styled` - this trait is useful for widgets that want to
+  support the Stylize trait, but it adds complexity as widgets have two
+  `style` methods and a `set_style` method.
+- `symbols::Marker` - this item is used by code that needs to draw to
+  the `Canvas` widget, but it's not a common item that would be used by
+  most users of the library.
+- `terminal::{CompletedFrame, TerminalOptions, Viewport}` - these items
+  are rarely used by code that needs to interact with the terminal, and
+  they're generally only ever used once in any app.
+
+The following items have been added to the prelude:
+
+- `layout::{Position, Size}` - these items are used by code that needs
+  to interact with the layout system. These are newer items that were
+  added in the last few releases, which should be used more liberally.
+  This may cause conflicts for types defined elsewhere with a similar
+  name.
+
+To update your app:
+
+```diff
+// if your app uses Styled::style() or Styled::set_style():
+-use ratatui::prelude::*;
++use ratatui::{prelude::*, style::Styled};
+
+// if your app uses symbols::Marker:
+-use ratatui::prelude::*;
++use ratatui::{prelude::*, symbols::Marker}
+
+// if your app uses terminal::{CompletedFrame, TerminalOptions, Viewport}
+-use ratatui::prelude::*;
++use ratatui::{prelude::*, terminal::{CompletedFrame, TerminalOptions, Viewport}};
+
+// to disambiguate existing types named Position or Size:
+- use some_crate::{Position, Size};
+- let size: Size = ...;
+- let position: Position = ...;
++ let size: some_crate::Size = ...;
++ let position: some_crate::Position = ...;
+```
+
+### Termion is updated to 4.0 [#1106]
+
+Changelog: <https://gitlab.redox-os.org/redox-os/termion/-/blob/master/CHANGELOG.md>
+
+A change is only necessary if you were matching on all variants of the `MouseEvent` enum without a
+wildcard. In this case, you need to either handle the two new variants, `MouseLeft` and
+`MouseRight`, or add a wildcard.
+
+[#1106]: https://github.com/ratatui/ratatui/pull/1106
+
+### `Rect::inner` takes `Margin` directly instead of reference ([#1008])
+
+[#1008]: https://github.com/ratatui/ratatui/pull/1008
+
+`Margin` needs to be passed without reference now.
+
+```diff
+-let area = area.inner(&Margin {
++let area = area.inner(Margin {
+     vertical: 0,
+     horizontal: 2,
+ });
+```
+
+### `Buffer::filled` takes `Cell` directly instead of reference ([#1148])
+
+[#1148]: https://github.com/ratatui/ratatui/pull/1148
+
+`Buffer::filled` moves the `Cell` instead of taking a reference.
+
+```diff
+-Buffer::filled(area, &Cell::new("X"));
++Buffer::filled(area, Cell::new("X"));
+```
+
+### `Stylize::bg()` now accepts `Into<Color>` ([#1103])
+
+[#1103]: https://github.com/ratatui/ratatui/pull/1103
+
+Previously, `Stylize::bg()` accepted `Color` but now accepts `Into<Color>`. This allows more
+flexible types from calling scopes, though it can break some type inference in the calling scope.
+
+### Remove deprecated `List::start_corner` and `layout::Corner` ([#759])
+
+[#759]: https://github.com/ratatui/ratatui/pull/759
+
+`List::start_corner` was deprecated in v0.25. Use `List::direction` and `ListDirection` instead.
+
+```diff
+- list.start_corner(Corner::TopLeft);
+- list.start_corner(Corner::TopRight);
+// This is not an error, BottomRight rendered top to bottom previously
+- list.start_corner(Corner::BottomRight);
+// all becomes
++ list.direction(ListDirection::TopToBottom);
+```
+
+```diff
+- list.start_corner(Corner::BottomLeft);
+// becomes
++ list.direction(ListDirection::BottomToTop);
+```
+
+`layout::Corner` was removed entirely.
+
+### `LineGauge::gauge_style` is deprecated ([#565])
+
+[#565]: https://github.com/ratatui/ratatui/pull/1148
+
+`LineGauge::gauge_style` is deprecated and replaced with `LineGauge::filled_style` and `LineGauge::unfilled_style`:
+
+```diff
+let gauge = LineGauge::default()
+- .gauge_style(Style::default().fg(Color::Red).bg(Color::Blue)
++ .filled_style(Style::default().fg(Color::Green))
++ .unfilled_style(Style::default().fg(Color::White));
+```
+
+## [v0.26.0](https://github.com/ratatui/ratatui/releases/tag/v0.26.0)
 
 ### `Flex::Start` is the new default flex mode for `Layout` ([#881])
 
-[#881]: https://github.com/ratatui-org/ratatui/pull/881
+[#881]: https://github.com/ratatui/ratatui/pull/881
 
 Previously, constraints would stretch to fill all available space, violating constraints if
 necessary.
@@ -72,9 +759,9 @@ existing layouts with `Flex::Start`. However, to get old behavior, use `Flex::Le
 
 ### `Table::new()` now accepts `IntoIterator<Item: Into<Row<'a>>>` ([#774])
 
-[#774]: https://github.com/ratatui-org/ratatui/pull/774
+[#774]: https://github.com/ratatui/ratatui/pull/774
 
-Previously, `Table::new()` accepted `IntoIterator<Item=Row<'a>>`.  The argument change to
+Previously, `Table::new()` accepted `IntoIterator<Item=Row<'a>>`. The argument change to
 `IntoIterator<Item: Into<Row<'a>>>`, This allows more flexible types from calling scopes, though it
 can some break type inference in the calling scope for empty containers.
 
@@ -89,9 +776,9 @@ This can be resolved either by providing an explicit type (e.g. `Vec::<Row>::new
 
 ### `Tabs::new()` now accepts `IntoIterator<Item: Into<Line<'a>>>` ([#776])
 
-[#776]: https://github.com/ratatui-org/ratatui/pull/776
+[#776]: https://github.com/ratatui/ratatui/pull/776
 
-Previously, `Tabs::new()` accepted `Vec<T>` where `T: Into<Line<'a>>`.  This allows more flexible
+Previously, `Tabs::new()` accepted `Vec<T>` where `T: Into<Line<'a>>`. This allows more flexible
 types from calling scopes, though it can break some type inference in the calling scope.
 
 This typically occurs when collecting an iterator prior to calling `Tabs::new`, and can be resolved
@@ -105,7 +792,7 @@ by removing the call to `.collect()`.
 
 ### Table::default() now sets segment_size to None and column_spacing to ([#751])
 
-[#751]: https://github.com/ratatui-org/ratatui/pull/751
+[#751]: https://github.com/ratatui/ratatui/pull/751
 
 The default() implementation of Table now sets the column_spacing field to 1 and the segment_size
 field to `SegmentSize::None`. This will affect the rendering of a small amount of apps.
@@ -115,7 +802,7 @@ To use the previous default values, call `table.segment_size(Default::default())
 
 ### `patch_style` & `reset_style` now consumes and returns `Self` ([#754])
 
-[#754]: https://github.com/ratatui-org/ratatui/pull/754
+[#754]: https://github.com/ratatui/ratatui/pull/754
 
 Previously, `patch_style` and `reset_style` in `Text`, `Line` and `Span` were using a mutable
 reference to `Self`. To be more consistent with the rest of `ratatui`, which is using fluent
@@ -132,8 +819,6 @@ The following example shows how to migrate for `Line`, but the same applies for
 
 ### Remove deprecated `Block::title_on_bottom` ([#757])
 
-[#757]: https://github.com/ratatui-org/ratatui/pull/757
-
 `Block::title_on_bottom` was deprecated in v0.22. Use `Block::title` and `Title::position` instead.
 
 ```diff
@@ -143,7 +828,7 @@ The following example shows how to migrate for `Line`, but the same applies for
 
 ### `Block` style methods cannot be used in a const context ([#720])
 
-[#720]: https://github.com/ratatui-org/ratatui/pull/720
+[#720]: https://github.com/ratatui/ratatui/pull/720
 
 Previously the `style()`, `border_style()` and `title_style()` methods could be used to create a
 `Block` in a constant context. These now accept `Into<Style>` instead of `Style`. These methods no
@@ -151,7 +836,7 @@ longer can be called from a constant context.
 
 ### `Line` now has a `style` field that applies to the entire line ([#708])
 
-[#708]: https://github.com/ratatui-org/ratatui/pull/708
+[#708]: https://github.com/ratatui/ratatui/pull/708
 
 Previously the style of a `Line` was stored in the `Span`s that make up the line. Now the `Line`
 itself has a `style` field, which can be set with the `Line::styled` method. Any code that creates
@@ -175,11 +860,11 @@ the `Span::style` field.
       .alignment(Alignment::Left);
 ```
 
-## [v0.25.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.25.0)
+## [v0.25.0](https://github.com/ratatui/ratatui/releases/tag/v0.25.0)
 
 ### Removed `Axis::title_style` and `Buffer::set_background` ([#691])
 
-[#691]: https://github.com/ratatui-org/ratatui/pull/691
+[#691]: https://github.com/ratatui/ratatui/pull/691
 
 These items were deprecated since 0.10.
 
@@ -193,7 +878,7 @@ These items were deprecated since 0.10.
 
 ### `List::new()` now accepts `IntoIterator<Item = Into<ListItem<'a>>>` ([#672])
 
-[#672]: https://github.com/ratatui-org/ratatui/pull/672
+[#672]: https://github.com/ratatui/ratatui/pull/672
 
 Previously `List::new()` took `Into<Vec<ListItem<'a>>>`. This change will throw a compilation
 error for `IntoIterator`s with an indeterminate item (e.g. empty vecs).
@@ -208,7 +893,7 @@ E.g.
 
 ### The default `Tabs::highlight_style` is now `Style::new().reversed()` ([#635])
 
-[#635]: https://github.com/ratatui-org/ratatui/pull/635
+[#635]: https://github.com/ratatui/ratatui/pull/635
 
 Previously the default highlight style for tabs was `Style::default()`, which meant that a `Tabs`
 widget in the default configuration would not show any indication of the selected tab.
@@ -220,7 +905,7 @@ widget in the default configuration would not show any indication of the selecte
 
 ### `Table::new()` now requires specifying the widths of the columns ([#664])
 
-[#664]: https://github.com/ratatui-org/ratatui/pull/664
+[#664]: https://github.com/ratatui/ratatui/pull/664
 
 Previously `Table`s could be constructed without `widths`. In almost all cases this is an error.
 A new `widths` parameter is now mandatory on `Table::new()`. Existing code of the form:
@@ -246,7 +931,7 @@ or complex, it may be convenient to replace `Table::new` with `Table::default().
 
 ### `Table::widths()` now accepts `IntoIterator<Item = AsRef<Constraint>>` ([#663])
 
-[#663]: https://github.com/ratatui-org/ratatui/pull/663
+[#663]: https://github.com/ratatui/ratatui/pull/663
 
 Previously `Table::widths()` took a slice (`&'a [Constraint]`). This change will introduce clippy
 `needless_borrow` warnings for places where slices are passed to this method. To fix these, remove
@@ -262,7 +947,7 @@ E.g.
 
 ### Layout::new() now accepts direction and constraint parameters ([#557])
 
-[#557]: https://github.com/ratatui-org/ratatui/pull/557
+[#557]: https://github.com/ratatui/ratatui/pull/557
 
 Previously layout new took no parameters. Existing code should either use `Layout::default()` or
 the new constructor.
@@ -279,18 +964,18 @@ let layout = layout::default()
 let layout = layout::new(Direction::Vertical, [Constraint::Min(1), Constraint::Max(2)]);
 ```
 
-## [v0.24.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.24.0)
+## [v0.24.0](https://github.com/ratatui/ratatui/releases/tag/v0.24.0)
 
 ### `ScrollbarState` field type changed from `u16` to `usize` ([#456])
 
-[#456]: https://github.com/ratatui-org/ratatui/pull/456
+[#456]: https://github.com/ratatui/ratatui/pull/456
 
 In order to support larger content lengths, the `position`, `content_length` and
 `viewport_content_length` methods on `ScrollbarState` now take `usize` instead of `u16`
 
 ### `BorderType::line_symbols` renamed to `border_symbols` ([#529])
 
-[#529]: https://github.com/ratatui-org/ratatui/issues/529
+[#529]: https://github.com/ratatui/ratatui/issues/529
 
 Applications can now set custom borders on a `Block` by calling `border_set()`. The
 `BorderType::line_symbols()` is renamed to `border_symbols()` and now returns a new struct
@@ -304,7 +989,7 @@ Applications can now set custom borders on a `Block` by calling `border_set()`.
 
 ### Generic `Backend` parameter removed from `Frame` ([#530])
 
-[#530]: https://github.com/ratatui-org/ratatui/issues/530
+[#530]: https://github.com/ratatui/ratatui/issues/530
 
 `Frame` is no longer generic over Backend. Code that accepted `Frame<Backend>` will now need to
 accept `Frame`. To migrate existing code, remove any generic parameters from code that uses an
@@ -318,7 +1003,7 @@ instance of a Frame. E.g.:
 
 ### `Stylize` shorthands now consume rather than borrow `String` ([#466])
 
-[#466]: https://github.com/ratatui-org/ratatui/issues/466
+[#466]: https://github.com/ratatui/ratatui/issues/466
 
 In order to support using `Stylize` shorthands (e.g. `"foo".red()`) on temporary `String` values, a
 new implementation of `Stylize` was added that returns a `Span<'static>`. This causes the value to
@@ -336,7 +1021,7 @@ longer compile. E.g.
 
 ### Deprecated `Spans` type removed (replaced with `Line`) ([#426])
 
-[#426]: https://github.com/ratatui-org/ratatui/issues/426
+[#426]: https://github.com/ratatui/ratatui/issues/426
 
 `Spans` was replaced with `Line` in 0.21.0. `Buffer::set_spans` was replaced with
 `Buffer::set_line`.
@@ -349,11 +1034,11 @@ longer compile. E.g.
 + buffer.set_line(0, 0, line, 10);
 ```
 
-## [v0.23.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.23.0)
+## [v0.23.0](https://github.com/ratatui/ratatui/releases/tag/v0.23.0)
 
 ### `Scrollbar::track_symbol()` now takes an `Option<&str>` instead of `&str` ([#360])
 
-[#360]: https://github.com/ratatui-org/ratatui/issues/360
+[#360]: https://github.com/ratatui/ratatui/issues/360
 
 The track symbol of `Scrollbar` is now optional, this method now takes an optional value.
 
@@ -365,7 +1050,7 @@ The track symbol of `Scrollbar` is now optional, this method now takes an option
 
 ### `Scrollbar` symbols moved to `symbols::scrollbar` and `widgets::scrollbar` module is private ([#330])
 
-[#330]: https://github.com/ratatui-org/ratatui/issues/330
+[#330]: https://github.com/ratatui/ratatui/issues/330
 
 The symbols for defining scrollbars have been moved to the `symbols` module from the
 `widgets::scrollbar` module which is no longer public. To update your code update any imports to the
@@ -379,31 +1064,31 @@ new module locations. E.g.:
 
 ### MSRV updated to 1.67 ([#361])
 
-[#361]: https://github.com/ratatui-org/ratatui/issues/361
+[#361]: https://github.com/ratatui/ratatui/issues/361
 
 The MSRV of ratatui is now 1.67 due to an MSRV update in a dependency (`time`).
 
-## [v0.22.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.22.0)
+## [v0.22.0](https://github.com/ratatui/ratatui/releases/tag/v0.22.0)
 
 ### `bitflags` updated to 2.3 ([#205])
 
-[#205]: https://github.com/ratatui-org/ratatui/issues/205
+[#205]: https://github.com/ratatui/ratatui/issues/205
 
-The `serde` representation of `bitflags` has changed. Any existing serialized types that have Borders or
-Modifiers will need to be re-serialized. This is documented in the [`bitflags`
+The `serde` representation of `bitflags` has changed. Any existing serialized types that have
+Borders or Modifiers will need to be re-serialized. This is documented in the [`bitflags`
 changelog](https://github.com/bitflags/bitflags/blob/main/CHANGELOG.md#200-rc2)..
 
-## [v0.21.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.21.0)
+## [v0.21.0](https://github.com/ratatui/ratatui/releases/tag/v0.21.0)
 
 ### MSRV is 1.65.0 ([#171])
 
-[#171]: https://github.com/ratatui-org/ratatui/issues/171
+[#171]: https://github.com/ratatui/ratatui/issues/171
 
 The minimum supported rust version is now 1.65.0.
 
 ### `Terminal::with_options()` stabilized to allow configuring the viewport ([#114])
 
-[#114]: https://github.com/ratatui-org/ratatui/issues/114
+[#114]: https://github.com/ratatui/ratatui/issues/114
 
 In order to support inline viewports, the unstable method `Terminal::with_options()` was stabilized
 and `ViewPort` was changed from a struct to an enum.
@@ -420,7 +1105,7 @@ let terminal = Terminal::with_options(backend, TerminalOptions {
 
 ### Code that binds `Into<Text<'a>>` now requires type annotations ([#168])
 
-[#168]: https://github.com/ratatui-org/ratatui/issues/168
+[#168]: https://github.com/ratatui/ratatui/issues/168
 
 A new type `Masked` was introduced that implements `From<Text<'a>>`. This causes any code that
 previously did not need to use type annotations to fail to compile. To fix this, annotate or call
@@ -434,9 +1119,9 @@ previously did not need to use type annotations to fail to compile. To fix this,
 
 ### `Marker::Block` now renders as a block rather than a bar character ([#133])
 
-[#133]: https://github.com/ratatui-org/ratatui/issues/133
+[#133]: https://github.com/ratatui/ratatui/issues/133
 
-Code using the `Block` marker that previously rendered using a half block character (`'▀'``) now
+Code using the `Block` marker that previously rendered using a half block character (`'▀'`) now
 renders using the full block character (`'█'`). A new marker variant`Bar` is introduced to replace
 the existing code.
 
@@ -446,20 +1131,20 @@ the existing code.
 + let canvas = Canvas::default().marker(Marker::Bar);
 ```
 
-## [v0.20.0](https://github.com/ratatui-org/ratatui/releases/tag/v0.20.0)
+## [v0.20.0](https://github.com/ratatui/ratatui/releases/tag/v0.20.0)
 
 v0.20.0 was the first release of Ratatui - versions prior to this were release as tui-rs. See the
 [Changelog](./CHANGELOG.md) for more details.
 
 ### MSRV is update to 1.63.0 ([#80])
 
-[#80]: https://github.com/ratatui-org/ratatui/issues/80
+[#80]: https://github.com/ratatui/ratatui/issues/80
 
 The minimum supported rust version is 1.63.0
 
 ### List no longer ignores empty string in items ([#42])
 
-[#42]: https://github.com/ratatui-org/ratatui/issues/42
+[#42]: https://github.com/ratatui/ratatui/issues/42
 
 The following code now renders 3 items instead of 2. Code which relies on the previous behavior will
 need to manually filter empty items prior to display.

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+https://forum.ratatui.rs/ or https://discord.gg/pMCEU9hNEj.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -6,9 +6,26 @@ If your contribution is not straightforward, please first discuss the change you
 creating a new issue before making the change, or starting a discussion on
 [discord](https://discord.gg/pMCEU9hNEj).
 
+## AI Generated Content
+
+We welcome high quality PRs, whether they are human generated or made with the assistance of AI
+tools, but we ask that you follow these guidelines:
+
+- **Attribution**: Tell us about your use of AI tools, don't make us guess whether you're using it.
+- **Review**: Make sure you review every line of AI generated content for correctness and relevance.
+- **Quality**: AI-generated content should meet the same quality standards as human-written content.
+- **Quantity**: Avoid submitting large amounts of AI generated content in a single PR. Remember that
+  quality is usually more important than quantity.
+- **License**: Ensure that the AI-generated content is compatible with Ratatui's
+  [License](./LICENSE).
+
+> [!IMPORTANT]
+> Remember that AI tools can assist in generating content, but you are responsible for the final
+> quality and accuracy of the contributions and communicating about it.
+
 ## Reporting issues
 
-Before reporting an issue on the [issue tracker](https://github.com/ratatui-org/ratatui/issues),
+Before reporting an issue on the [issue tracker](https://github.com/ratatui/ratatui/issues),
 please check that it has not already been reported by searching for some related keywords. Please
 also check [`tui-rs` issues](https://github.com/fdehau/tui-rs/issues/) and link any related issues
 found.
@@ -17,22 +34,53 @@ found.
 
 All contributions are obviously welcome. Please include as many details as possible in your PR
 description to help the reviewer (follow the provided template). Make sure to highlight changes
-which may need additional attention or you are uncertain about. Any idea with a large scale impact
+which may need additional attention, or you are uncertain about. Any idea with a large scale impact
 on the crate or its users should ideally be discussed in a "Feature Request" issue beforehand.
 
-### Keep PRs small, intentional and focused
+### Keep PRs small, intentional, and focused
 
-Try to do one pull request per change. The time taken to review a PR grows exponential with the size
-of the change. Small focused PRs will generally be much more faster to review. PRs that include both
+Try to do one pull request per change. The time taken to review a PR grows exponentially with the size
+of the change. Small focused PRs will generally be much faster to review. PRs that include both
 refactoring (or reformatting) with actual changes are more difficult to review as every line of the
 change becomes a place where a bug may have been introduced. Consider splitting refactoring /
 reformatting changes into a separate PR from those that make a behavioral change, as the tests help
 guarantee that the behavior is unchanged.
 
+Guidelines for PR size:
+
+- Aim for PRs under 500 lines of changes when possible.
+- Split large features into incremental PRs that build on each other.
+- Separate refactoring, formatting, and functional changes into different PRs.
+- If a large PR is unavoidable, clearly explain why in the PR description.
+
+### Breaking changes and backwards compatibility
+
+We prioritize maintaining backwards compatibility and minimizing disruption to users:
+
+- **Prefer deprecation over removal**: Add deprecation warnings rather than immediately removing
+  public APIs
+- **Provide migration paths**: Include clear upgrade instructions for any breaking changes
+- **Follow our deprecation policy**: Wait at least two versions before removing deprecated items
+- **Consider feature flags**: Use feature flags for experimental or potentially disruptive changes
+- **Document breaking changes**: Clearly mark breaking changes in commit messages and PR descriptions
+
+See our [deprecation notice policy](#deprecation-notice) for more details.
+
 ### Code formatting
 
-Run `cargo make format` before committing to ensure that code is consistently formatted with
-rustfmt. Configuration is in [rustfmt.toml](./rustfmt.toml).
+Run `cargo xtask format` before committing to ensure that code is consistently formatted with
+rustfmt. Configuration is in [`rustfmt.toml`](./rustfmt.toml). We use some unstable formatting
+options as they lead to subjectively better formatting. These require a nightly version of Rust
+to be installed when running rustfmt. You can install the nightly version of Rust using
+[`rustup`](https://rustup.rs/):
+
+```shell
+rustup install nightly
+```
+
+> [!IMPORTANT]
+> Do not modify formatting configuration (`rustfmt.toml`, `.clippy.toml`) without
+> prior discussion. These changes affect all contributors and should be carefully considered.
 
 ### Search `tui-rs` for similar work
 
@@ -56,11 +104,18 @@ documented.
 
 ### Run CI tests before pushing a PR
 
-We're using [cargo-husky](https://github.com/rhysd/cargo-husky) to automatically run git hooks,
-which will run `cargo make ci` before each push. To initialize the hook  run `cargo test`. If
-`cargo-make` is not installed, it will provide instructions to install it for you. This will ensure
-that your code is formatted, compiles and passes all tests before you push. If you need to skip this
-check, you can use `git push --no-verify`.
+Running `cargo xtask ci` before pushing will perform the same checks that we do in the CI process.
+It's not mandatory to do this before pushing, however it may save you time to do so instead of
+waiting for GitHub to run the checks.
+
+Available xtask commands:
+
+- `cargo xtask ci` - Run all CI checks
+- `cargo xtask format` - Format code
+- `cargo xtask lint` - Run linting checks
+- `cargo xtask test` - Run all tests
+
+Run `cargo xtask --help` to see all available commands.
 
 ### Sign your commits
 
@@ -69,31 +124,64 @@ they are signed. To set up your machine to sign commits, see [managing commit si
 verification](https://docs.github.com/en/authentication/managing-commit-signature-verification/about-commit-signature-verification)
 in GitHub docs.
 
+### Configuration and build system changes
+
+Changes to project configuration files require special consideration:
+
+- Linting configuration (`.clippy.toml`, `rustfmt.toml`): Affects all contributors.
+- CI configuration (`.github/workflows/`): Affects build and deployment.
+- Build system (`xtask/`, `Cargo.toml` workspace config): Affects development workflow.
+- Dependencies: Consider MSRV compatibility and licensing.
+
+Please discuss these changes in an issue before implementing them.
+
+### Collaborative development
+
+We may occasionally make changes directly to your branch—such as force-pushes—to help move a PR
+forward, speed up review, or ensure it meets our quality standards. If you would prefer we do not do
+this, or if your workflow depends on us avoiding force-pushes (for example, if your app points to
+your branch in `Cargo.toml`), please mention this in your PR description and we will respect your
+preference.
+
 ## Implementation Guidelines
 
 ### Setup
 
-Clone the repo and build it using [cargo-make](https://sagiegurari.github.io/cargo-make/)
+TL;DR: Clone the repo and build it using `cargo xtask`.
 
 Ratatui is an ordinary Rust project where common tasks are managed with
-[cargo-make](https://github.com/sagiegurari/cargo-make/). It wraps common `cargo` commands with sane
+[cargo-xtask](https://github.com/matklad/cargo-xtask). It wraps common `cargo` commands with sane
 defaults depending on your platform of choice. Building the project should be as easy as running
-`cargo make build`.
+`cargo xtask build`.
 
 ```shell
-git clone https://github.com/ratatui-org/ratatui.git
+git clone https://github.com/ratatui/ratatui.git
 cd ratatui
-cargo make build
+cargo xtask build
 ```
 
+### Architecture
+
+For an understanding of the crate organization and design decisions, see [ARCHITECTURE.md]. This
+document explains the modular workspace structure introduced in version 0.30.0 and provides
+guidance on which crate to use for different use cases.
+
+When making changes, consider:
+
+- Which crate should contain your changes per the modular structure,
+- Whether your changes affect the public API of `ratatui-core` (requires extra care),
+- And how your changes fit into the overall architecture.
+
+[ARCHITECTURE.md]: https://github.com/ratatui/ratatui/blob/main/ARCHITECTURE.md
+
 ### Tests
 
-The [test coverage](https://app.codecov.io/gh/ratatui-org/ratatui) of the crate is reasonably
+The [test coverage](https://app.codecov.io/gh/ratatui/ratatui) of the crate is reasonably
 good, but this can always be improved. Focus on keeping the tests simple and obvious and write unit
 tests for all new or modified code. Beside the usual doc and unit tests, one of the most valuable
 test you can write for Ratatui is a test against the `TestBackend`. It allows you to assert the
 content of the output buffer that would have been flushed to the terminal after a given draw call.
-See `widgets_block_renders` in [tests/widgets_block.rs](./tests/widget_block.rs) for an example.
+See `widgets_block_renders` in [ratatui/tests/widgets_block.rs](./ratatui/tests/widgets_block.rs) for an example.
 
 When writing tests, generally prefer to write unit tests and doc tests directly in the code file
 being tested rather than integration tests in the `tests/` folder.
@@ -102,6 +190,10 @@ If an area that you're making a change in is not tested, write tests to characte
 behavior before changing it. This helps ensure that we don't introduce bugs to existing software
 using Ratatui (and helps make it easy to migrate apps still using `tui-rs`).
 
+> [!IMPORTANT]
+> Do not remove existing tests without clear justification. If tests need to be
+> modified due to API changes, explain why in your PR description.
+
 For coverage, we have two [bacon](https://dystroy.org/bacon/) jobs (one for all tests, and one for
 unit tests, keyboard shortcuts `v` and `u` respectively) that run
 [cargo-llvm-cov](https://github.com/taiki-e/cargo-llvm-cov) to report the coverage. Several plugins
@@ -149,7 +241,7 @@ fn foo() {}
 ```
 
 - Max line length is 100 characters
-See [vscode rewrap extension](https://marketplace.visualstudio.com/items?itemName=stkb.rewrap)
+See [VS Code rewrap extension](https://marketplace.visualstudio.com/items?itemName=stkb.rewrap)
 
 - Doc comments are above macros
 i.e.
@@ -165,26 +257,34 @@ i.e. ``[`Block`]``, **NOT** ``[Block]``
 
 ### Deprecation notice
 
-We generally want to wait at least two versions before removing deprecated items so users have
+We generally want to wait at least two versions before removing deprecated items, so users have
 time to update. However, if a deprecation is blocking for us to implement a new feature we may
 *consider* removing it in a one version notice.
 
+Deprecation process:
+
+1. Add `#[deprecated]` attribute with a clear message.
+2. Update documentation to point to the replacement.
+3. Add an entry to `BREAKING-CHANGES.md` if applicable.
+4. Wait at least two versions before removal.
+5. Consider the impact on the ecosystem before removing.
+
 ### Use of unsafe for optimization purposes
 
-We don't currently use any unsafe code in Ratatui, and would like to keep it that way. However there
+We don't currently use any unsafe code in Ratatui, and would like to keep it that way. However, there
 may be specific cases that this becomes necessary in order to avoid slowness. Please see [this
-discussion](https://github.com/ratatui-org/ratatui/discussions/66) for more about the decision.
+discussion](https://github.com/ratatui/ratatui/discussions/66) for more about the decision.
 
 ## Continuous Integration
 
-We use Github Actions for the CI where we perform the following checks:
+We use GitHub Actions for the CI where we perform the following checks:
 
 - The code should compile on `stable` and the Minimum Supported Rust Version (MSRV).
 - The tests (docs, lib, tests and examples) should pass.
 - The code should conform to the default format enforced by `rustfmt`.
 - The code should not contain common style issues `clippy`.
 
-You can also check most of those things yourself locally using `cargo make ci` which will offer you
+You can also check most of those things yourself locally using `cargo xtask ci` which will offer you
 a shorter feedback loop than pushing to github.
 
 ## Relationship with `tui-rs`
@@ -193,12 +293,12 @@ This project was forked from [`tui-rs`](https://github.com/fdehau/tui-rs/) in Fe
 [blessing of the original author](https://github.com/fdehau/tui-rs/issues/654), Florian Dehau
 ([@fdehau](https://github.com/fdehau)).
 
-The original repository contains all the issues, PRs and discussion that were raised originally, and
+The original repository contains all the issues, PRs, and discussion that were raised originally, and
 it is useful to refer to when contributing code, documentation, or issues with Ratatui.
 
-We imported all the PRs from the original repository and implemented many of the smaller ones and
+We imported all the PRs from the original repository, implemented many of the smaller ones, and
 made notes on the leftovers. These are marked as draft PRs and labelled as [imported from
-tui](https://github.com/ratatui-org/ratatui/pulls?q=is%3Apr+is%3Aopen+label%3A%22imported+from+tui%22).
+tui](https://github.com/ratatui/ratatui/pulls?q=is%3Apr+is%3Aopen+label%3A%22imported+from+tui%22).
 We have documented the current state of those PRs, and anyone is welcome to pick them up and
 continue the work on them.
 

Cargo.toml

@@ -1,73 +1,90 @@
-[package]
-name = "ratatui"
-version = "0.26.2" # crate version
+[workspace]
+resolver = "2"
+members = ["ratatui", "ratatui-*", "xtask", "examples/apps/*", "examples/concepts/*"]
+default-members = [
+  "ratatui",
+  "ratatui-core",
+  "ratatui-crossterm",
+  # this is not included as it doesn't compile on windows
+  # "ratatui-termion",
+  "ratatui-macros",
+  "ratatui-termwiz",
+  "ratatui-widgets",
+  "examples/apps/*",
+  "examples/concepts/*",
+]
+
+[workspace.package]
 authors = ["Florian Dehau <work@fdehau.com>", "The Ratatui Developers"]
-description = "A library that's all about cooking up terminal user interfaces"
 documentation = "https://docs.rs/ratatui/latest/ratatui/"
-repository = "https://github.com/ratatui-org/ratatui"
+repository = "https://github.com/ratatui/ratatui"
 homepage = "https://ratatui.rs"
 keywords = ["tui", "terminal", "dashboard"]
 categories = ["command-line-interface"]
 readme = "README.md"
 license = "MIT"
-exclude = [
-  "assets/*",
-  ".github",
-  "Makefile.toml",
-  "CONTRIBUTING.md",
-  "*.log",
-  "tags",
-]
-autoexamples = true
-edition = "2021"
-rust-version = "1.74.0"
+exclude = ["assets/*", ".github", "Makefile.toml", "CONTRIBUTING.md", "*.log", "tags"]
+edition = "2024"
+rust-version = "1.86.0"
 
-[badges]
+[workspace.dependencies]
+anstyle = "1"
+bitflags = "2.10"
+clap = { version = "4.5", features = ["derive"] }
+color-eyre = "0.6"
+compact_str = { version = "0.9", default-features = false }
+criterion = { version = "0.8", features = ["html_reports"] }
+crossterm = "0.29"
+document-features = "0.2"
+fakeit = "1"
+futures = "0.3"
+hashbrown = "0.16"
+indoc = "2"
+instability = "0.3"
+itertools = { version = "0.14", default-features = false, features = ["use_alloc"] }
+kasuari = { version = "0.4", default-features = false }
+line-clipping = "0.3"
+lru = "0.16"
+octocrab = "0.49"
+palette = "0.7"
+pretty_assertions = "1"
+rand = "0.9"
+rand_chacha = "0.9"
+ratatui = { path = "ratatui", version = "0.30.0" }
+ratatui-core = { path = "ratatui-core", version = "0.1.0" }
+ratatui-crossterm = { path = "ratatui-crossterm", version = "0.1.0" }
+ratatui-macros = { path = "ratatui-macros", version = "0.7.0" }
+ratatui-termion = { path = "ratatui-termion", version = "0.1.0" }
+ratatui-termwiz = { path = "ratatui-termwiz", version = "0.1.0" }
+ratatui-widgets = { path = "ratatui-widgets", version = "0.3.0" }
+rstest = "0.26"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+strum = { version = "0.27", default-features = false, features = ["derive"] }
+termion = "4"
+termwiz = "0.23"
+thiserror = { version = "2", default-features = false }
+time = { version = "0.3.37", default-features = false }
+tokio = "1"
+tokio-stream = "0.1"
+tracing = "0.1"
+tracing-appender = "0.2"
+tracing-subscriber = "0.3"
+trybuild = "1"
+unicode-segmentation = "1"
+unicode-truncate = { version = "2", default-features = false }
+# See <https://github.com/ratatui/ratatui/issues/1271> for information about why we pin unicode-width
+unicode-width = ">=0.2.0, <=0.2.2"
 
-[dependencies]
-crossterm = { version = "0.27", optional = true }
-termion = { version = "3.0", optional = true }
-termwiz = { version = "0.22.0", optional = true }
+# Improve benchmark consistency
+[profile.bench]
+codegen-units = 1
+lto = true
 
-serde = { version = "1", optional = true, features = ["derive"] }
-bitflags = "2.3"
-cassowary = "0.3"
-indoc = "2.0"
-itertools = "0.12"
-paste = "1.0.2"
-strum = { version = "0.26", features = ["derive"] }
-time = { version = "0.3.11", optional = true, features = ["local-offset"] }
-unicode-segmentation = "1.10"
-unicode-width = "0.1"
-document-features = { version = "0.2.7", optional = true }
-lru = "0.12.0"
-stability = "0.2.0"
-compact_str = "0.7.1"
-
-[dev-dependencies]
-anyhow = "1.0.71"
-argh = "0.1.12"
-better-panic = "0.3.0"
-cargo-husky = { version = "1.5.0", default-features = false, features = [
-  "user-hooks",
-] }
-color-eyre = "0.6.2"
-criterion = { version = "0.5.1", features = ["html_reports"] }
-derive_builder = "0.20.0"
-fakeit = "1.1"
-font8x8 = "0.3.1"
-palette = "0.7.3"
-pretty_assertions = "1.4.0"
-rand = "0.8.5"
-rand_chacha = "0.3.1"
-rstest = "0.19.0"
-serde_json = "1.0.109"
-
-[lints.rust]
+[workspace.lints.rust]
 unsafe_code = "forbid"
 
-[lints.clippy]
-cargo = { level = "warn", priority = -1 }
+[workspace.lints.clippy]
 pedantic = { level = "warn", priority = -1 }
 cast_possible_truncation = "allow"
 cast_possible_wrap = "allow"
@@ -77,7 +94,10 @@ missing_errors_doc = "allow"
 missing_panics_doc = "allow"
 module_name_repetitions = "allow"
 must_use_candidate = "allow"
-wildcard_imports = "allow"
+
+# we often split up a module into multiple files with the main type in a file named after the
+# module, so we want to allow this pattern
+module_inception = "allow"
 
 # nursery or restricted
 as_underscore = "warn"
@@ -87,245 +107,17 @@ empty_line_after_doc_comments = "warn"
 equatable_if_let = "warn"
 fn_to_numeric_cast_any = "warn"
 format_push_string = "warn"
+implicit_clone = "warn"
 map_err_ignore = "warn"
 missing_const_for_fn = "warn"
 mixed_read_write_in_expression = "warn"
 mod_module_files = "warn"
+needless_pass_by_ref_mut = "warn"
 needless_raw_strings = "warn"
+or_fun_call = "warn"
 redundant_type_annotations = "warn"
 rest_pat_in_fully_bound_structs = "warn"
 string_lit_chars_any = "warn"
-string_to_string = "warn"
+string_slice = "warn"
+unnecessary_self_imports = "warn"
 use_self = "warn"
-
-[features]
-#! The crate provides a set of optional features that can be enabled in your `cargo.toml` file.
-#!
-## By default, we enable the crossterm backend as this is a reasonable choice for most applications
-## as it is supported on Linux/Mac/Windows systems. We also enable the `underline-color` feature
-## which allows you to set the underline color of text.
-default = ["crossterm", "underline-color"]
-#! Generally an application will only use one backend, so you should only enable one of the following features:
-## enables the [`CrosstermBackend`] backend and adds a dependency on the [Crossterm crate].
-crossterm = ["dep:crossterm"]
-## enables the [`TermionBackend`] backend and adds a dependency on the [Termion crate].
-termion = ["dep:termion"]
-## enables the [`TermwizBackend`] backend and adds a dependency on the [Termwiz crate].
-termwiz = ["dep:termwiz"]
-
-#! The following optional features are available for all backends:
-## enables serialization and deserialization of style and color types using the [Serde crate].
-## This is useful if you want to save themes to a file.
-serde = ["dep:serde", "bitflags/serde", "compact_str/serde"]
-
-## enables the [`border!`] macro.
-macros = []
-
-## enables all widgets.
-all-widgets = ["widget-calendar"]
-
-#! Widgets that add dependencies are gated behind feature flags to prevent unused transitive
-#! dependencies. The available features are:
-## enables the [`calendar`] widget module and adds a dependency on the [Time crate].
-widget-calendar = ["dep:time"]
-
-#! Underline color is only supported by the [`CrosstermBackend`] backend, and is not supported
-#! on Windows 7.
-## enables the backend code that sets the underline color.
-underline-color = ["dep:crossterm"]
-
-#! The following features are unstable and may change in the future:
-
-## Enable all unstable features.
-unstable = ["unstable-rendered-line-info", "unstable-widget-ref"]
-
-## Enables the [`Paragraph::line_count`](crate::widgets::Paragraph::line_count)
-## [`Paragraph::line_width`](crate::widgets::Paragraph::line_width) methods
-## which are experimental and may change in the future.
-## See [Issue 293](https://github.com/ratatui-org/ratatui/issues/293) for more details.
-unstable-rendered-line-info = []
-
-## Enables the `WidgetRef` and `StatefulWidgetRef` traits which are experimental and may change in
-## the future.
-unstable-widget-ref = []
-
-[package.metadata.docs.rs]
-all-features = true
-# see https://doc.rust-lang.org/nightly/rustdoc/scraped-examples.html
-cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
-rustdoc-args = ["--cfg", "docsrs"]
-
-[[bench]]
-name = "barchart"
-harness = false
-
-[[bench]]
-name = "block"
-harness = false
-
-[[bench]]
-name = "list"
-harness = false
-
-[lib]
-bench = false
-
-[[bench]]
-name = "paragraph"
-harness = false
-
-[[bench]]
-name = "sparkline"
-harness = false
-
-
-[[example]]
-name = "barchart"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "block"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "canvas"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "calendar"
-required-features = ["crossterm", "widget-calendar"]
-doc-scrape-examples = true
-
-[[example]]
-name = "chart"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "colors"
-required-features = ["crossterm"]
-# this example is a bit verbose, so we don't want to include it in the docs
-doc-scrape-examples = false
-
-[[example]]
-name = "colors_rgb"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "custom_widget"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "demo"
-# this runs for all of the terminal backends, so it can't be built using --all-features or scraped
-doc-scrape-examples = false
-
-[[example]]
-name = "demo2"
-required-features = ["crossterm", "widget-calendar"]
-doc-scrape-examples = true
-
-[[example]]
-name = "docsrs"
-required-features = ["crossterm"]
-doc-scrape-examples = false
-
-[[example]]
-name = "gauge"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "hello_world"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "layout"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "constraints"
-required-features = ["crossterm"]
-doc-scrape-examples = false
-
-[[example]]
-name = "flex"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "constraint-explorer"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "list"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "modifiers"
-required-features = ["crossterm"]
-# this example is a bit verbose, so we don't want to include it in the docs
-doc-scrape-examples = false
-
-[[example]]
-name = "panic"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "paragraph"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "popup"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "ratatui-logo"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "scrollbar"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "sparkline"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "table"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "tabs"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "user_input"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "inline"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[test]]
-name = "state_serde"
-required-features = ["serde"]

LICENSE

@@ -1,7 +1,7 @@
 The MIT License (MIT)
 
 Copyright (c) 2016-2022 Florian Dehau
-Copyright (c) 2023-2024 The Ratatui Developers
+Copyright (c) 2023-2025 The Ratatui Developers
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

MAINTAINERS.md

@@ -0,0 +1,16 @@
+# Maintainers
+
+This file documents current and past maintainers.
+
+- [orhun](https://github.com/orhun)
+- [joshka](https://github.com/joshka)
+- [kdheepak](https://github.com/kdheepak)
+- [j-g00da](https://github.com/j-g00da)
+
+## Past Maintainers
+
+- [fdehau](https://github.com/fdehau)
+- [mindoodoo](https://github.com/mindoodoo)
+- [sayanarijit](https://github.com/sayanarijit)
+- [EdJoPaTo](https://github.com/EdJoPaTo)
+- [Valentin271](https://github.com/Valentin271)

Makefile.toml

@@ -1,174 +0,0 @@
-# configuration for https://github.com/sagiegurari/cargo-make
-
-[config]
-skip_core_tasks = true
-
-[env]
-# all features except the backend ones
-ALL_FEATURES = "all-widgets,macros,serde"
-
-# Windows does not support building termion, so this avoids the build failure by providing two
-# sets of flags, one for Windows and one for other platforms.
-# Windows: --features=all-widgets,macros,serde,crossterm,termwiz,underline-color
-# Other: --features=all-widgets,macros,serde,crossterm,termion,termwiz,underline-color
-ALL_FEATURES_FLAG = { source = "${CARGO_MAKE_RUST_TARGET_OS}", default_value = "--features=all-widgets,macros,serde,crossterm,termion,termwiz,unstable", mapping = { "windows" = "--features=all-widgets,macros,serde,crossterm,termwiz,unstable" } }
-
-[tasks.default]
-alias = "ci"
-
-[tasks.ci]
-description = "Run continuous integration tasks"
-dependencies = ["lint-style", "clippy", "check", "test"]
-
-[tasks.lint-style]
-description = "Lint code style (formatting, typos, docs)"
-dependencies = ["lint-format", "lint-typos", "lint-docs"]
-
-[tasks.lint-format]
-description = "Lint code formatting"
-toolchain = "nightly"
-command = "cargo"
-args = ["fmt", "--all", "--check"]
-
-[tasks.format]
-description = "Fix code formatting"
-toolchain = "nightly"
-command = "cargo"
-args = ["fmt", "--all"]
-
-[tasks.lint-typos]
-description = "Run typo checks"
-install_crate = { crate_name = "typos-cli", binary = "typos", test_arg = "--version" }
-command = "typos"
-
-[tasks.lint-docs]
-description = "Check documentation for errors and warnings"
-toolchain = "nightly"
-command = "cargo"
-args = [
-  "rustdoc",
-  "--no-default-features",
-  "${ALL_FEATURES_FLAG}",
-  "--",
-  "-Zunstable-options",
-  "--check",
-  "-Dwarnings",
-]
-
-[tasks.check]
-description = "Check code for errors and warnings"
-command = "cargo"
-args = [
-  "check",
-  "--all-targets",
-  "--no-default-features",
-  "${ALL_FEATURES_FLAG}",
-]
-
-[tasks.build]
-description = "Compile the project"
-command = "cargo"
-args = [
-  "build",
-  "--all-targets",
-  "--no-default-features",
-  "${ALL_FEATURES_FLAG}",
-]
-
-[tasks.clippy]
-description = "Run Clippy for linting"
-command = "cargo"
-args = [
-  "clippy",
-  "--all-targets",
-  "--tests",
-  "--benches",
-  "--no-default-features",
-  "${ALL_FEATURES_FLAG}",
-  "--",
-  "-D",
-  "warnings",
-]
-
-[tasks.install-nextest]
-description = "Install cargo-nextest"
-install_crate = { crate_name = "cargo-nextest", binary = "cargo-nextest", test_arg = "--help" }
-
-[tasks.test]
-description = "Run tests"
-run_task = { name = ["test-lib", "test-doc"] }
-
-[tasks.test-lib]
-description = "Run default tests"
-dependencies = ["install-nextest"]
-command = "cargo"
-args = [
-  "nextest",
-  "run",
-  "--all-targets",
-  "--no-default-features",
-  "${ALL_FEATURES_FLAG}",
-]
-
-[tasks.test-doc]
-description = "Run documentation tests"
-command = "cargo"
-args = ["test", "--doc", "--no-default-features", "${ALL_FEATURES_FLAG}"]
-
-[tasks.test-backend]
-# takes a command line parameter to specify the backend to test (e.g. "crossterm")
-description = "Run backend-specific tests"
-dependencies = ["install-nextest"]
-command = "cargo"
-args = [
-  "nextest",
-  "run",
-  "--all-targets",
-  "--no-default-features",
-  "--features",
-  "${ALL_FEATURES},${@}",
-]
-
-[tasks.coverage]
-description = "Generate code coverage report"
-command = "cargo"
-args = [
-  "llvm-cov",
-  "--lcov",
-  "--output-path",
-  "target/lcov.info",
-  "--no-default-features",
-  "${ALL_FEATURES_FLAG}",
-]
-
-[tasks.run-example]
-private = true
-condition = { env_set = ["TUI_EXAMPLE_NAME"] }
-command = "cargo"
-args = [
-  "run",
-  "--release",
-  "--example",
-  "${TUI_EXAMPLE_NAME}",
-  "--features",
-  "all-widgets",
-]
-
-[tasks.build-examples]
-description = "Compile project examples"
-command = "cargo"
-args = ["build", "--examples", "--release", "--features", "all-widgets"]
-
-[tasks.run-examples]
-description = "Run project examples"
-dependencies = ["build-examples"]
-script = '''
-#!@duckscript
-files = glob_array ./examples/*.rs
-for file in ${files}
-  name = basename ${file}
-  name = substring ${name} -3
-  set_env TUI_EXAMPLE_NAME ${name}
-  cm_run_task run-example
-end
-'''

README.md

@@ -1,446 +1,182 @@
 <details>
 <summary>Table of Contents</summary>
 
-- [Ratatui](#ratatui)
-  - [Installation](#installation)
-  - [Introduction](#introduction)
-  - [Other Documentation](#other-documentation)
-  - [Quickstart](#quickstart)
-  - [Status of this fork](#status-of-this-fork)
-  - [Rust version requirements](#rust-version-requirements)
-  - [Widgets](#widgets)
-    - [Built in](#built-in)
-    - [Third\-party libraries, bootstrapping templates and
-      widgets](#third-party-libraries-bootstrapping-templates-and-widgets)
-  - [Apps](#apps)
-  - [Alternatives](#alternatives)
-  - [Acknowledgments](#acknowledgments)
-  - [License](#license)
+- [Quickstart](#quickstart)
+- [Documentation](#documentation)
+- [Templates](#templates)
+- [Built with Ratatui](#built-with-ratatui)
+- [Alternatives](#alternatives)
+- [Contributing](#contributing)
+- [Acknowledgements](#acknowledgements)
+- [License](#license)
 
 </details>
 
-<!-- cargo-rdme start -->
-
-![Demo](https://github.com/ratatui-org/ratatui/blob/1d39444e3dea6f309cf9035be2417ac711c1abc9/examples/demo2-destroy.gif?raw=true)
+![Release header](https://github.com/ratatui/ratatui/blob/b23480adfa9430697071c906c7ba4d4f9bd37a73/assets/release-header.png?raw=true)
 
 <div align="center">
 
-[![Crate Badge]][Crate] [![Docs Badge]][API Docs] [![CI Badge]][CI Workflow] [![License
-Badge]](./LICENSE) [![Sponsors Badge]][GitHub Sponsors]<br>
-[![Codecov Badge]][Codecov] [![Deps.rs Badge]][Deps.rs] [![Discord Badge]][Discord Server]
-[![Matrix Badge]][Matrix]<br>
-
-[Ratatui Website] · [API Docs] · [Examples] · [Changelog] · [Breaking Changes]<br>
-[Contributing] · [Report a bug] · [Request a Feature] · [Create a Pull Request]
+[![Crate Badge]][Crate] [![Repo Badge]][Repo] [![Docs Badge]][Docs] [![License Badge]][License]  \
+[![CI Badge]][CI] [![Deps Badge]][Deps] [![Codecov Badge]][Codecov] [![Sponsors Badge]][Sponsors]  \
+[Ratatui Website] · [Docs] · [Widget Examples] · [App Examples] · [Changelog]  \
+[Breaking Changes] · [Contributing] · [Report a bug] · [Request a Feature]
 
 </div>
 
-# Ratatui
-
-[Ratatui][Ratatui Website] is a crate for cooking up terminal user interfaces in Rust. It is a
-lightweight library that provides a set of widgets and utilities to build complex Rust TUIs.
-Ratatui was forked from the [tui-rs] crate in 2023 in order to continue its development.
-
-## Installation
-
-Add `ratatui` and `crossterm` as dependencies to your cargo.toml:
-
-```shell
-cargo add ratatui crossterm
-```
-
-Ratatui uses [Crossterm] by default as it works on most platforms. See the [Installation]
-section of the [Ratatui Website] for more details on how to use other backends ([Termion] /
-[Termwiz]).
-
-## Introduction
-
-Ratatui is based on the principle of immediate rendering with intermediate buffers. This means
-that for each frame, your app must render all widgets that are supposed to be part of the UI.
-This is in contrast to the retained mode style of rendering where widgets are updated and then
-automatically redrawn on the next frame. See the [Rendering] section of the [Ratatui Website]
-for more info.
-
-You can also watch the [FOSDEM 2024 talk] about Ratatui which gives a brief introduction to
-terminal user interfaces and showcases the features of Ratatui, along with a hello world demo.
-
-## Other documentation
-
-- [Ratatui Website] - explains the library's concepts and provides step-by-step tutorials
-- [API Docs] - the full API documentation for the library on docs.rs.
-- [Examples] - a collection of examples that demonstrate how to use the library.
-- [Contributing] - Please read this if you are interested in contributing to the project.
-- [Changelog] - generated by [git-cliff] utilizing [Conventional Commits].
-- [Breaking Changes] - a list of breaking changes in the library.
+[Ratatui][Ratatui Website] (_ˌræ.təˈtu.i_) is a Rust crate for cooking up terminal user interfaces
+(TUIs). It provides a simple and flexible way to create text-based user interfaces in the terminal,
+which can be used for command-line applications, dashboards, and other interactive console programs.
 
 ## Quickstart
 
-The following example demonstrates the minimal amount of code necessary to setup a terminal and
-render "Hello World!". The full code for this example which contains a little more detail is in
-the [Examples] directory. For more guidance on different ways to structure your application see
-the [Application Patterns] and [Hello World tutorial] sections in the [Ratatui Website] and the
-various [Examples]. There are also several starter templates available in the [templates]
-repository.
+Ratatui has [templates] available to help you get started quickly. You can use the
+[`cargo-generate`] command to create a new project with Ratatui:
 
-Every application built with `ratatui` needs to implement the following steps:
+```shell
+cargo install --locked cargo-generate
+cargo generate ratatui/templates
+```
 
-- Initialize the terminal
-- A main loop to:
-  - Handle input events
-  - Draw the UI
-- Restore the terminal state
-
-The library contains a [`prelude`] module that re-exports the most commonly used traits and
-types for convenience. Most examples in the documentation will use this instead of showing the
-full path of each type.
-
-### Initialize and restore the terminal
-
-The [`Terminal`] type is the main entry point for any Ratatui application. It is a light
-abstraction over a choice of [`Backend`] implementations that provides functionality to draw
-each frame, clear the screen, hide the cursor, etc. It is parametrized over any type that
-implements the [`Backend`] trait which has implementations for [Crossterm], [Termion] and
-[Termwiz].
-
-Most applications should enter the Alternate Screen when starting and leave it when exiting and
-also enable raw mode to disable line buffering and enable reading key events. See the [`backend`
-module] and the [Backends] section of the [Ratatui Website] for more info.
-
-### Drawing the UI
-
-The drawing logic is delegated to a closure that takes a [`Frame`] instance as argument. The
-[`Frame`] provides the size of the area to draw to and allows the app to render any [`Widget`]
-using the provided [`render_widget`] method. See the [Widgets] section of the [Ratatui Website]
-for more info.
-
-### Handling events
-
-Ratatui does not include any input handling. Instead event handling can be implemented by
-calling backend library methods directly. See the [Handling Events] section of the [Ratatui
-Website] for more info. For example, if you are using [Crossterm], you can use the
-[`crossterm::event`] module to handle events.
-
-### Example
+Selecting the Hello World template produces the following application:
 
 ```rust
-use std::io::{self, stdout};
+use color_eyre::Result;
+use crossterm::event::{self, Event};
+use ratatui::{DefaultTerminal, Frame};
 
-use crossterm::{
-    event::{self, Event, KeyCode},
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    ExecutableCommand,
-};
-use ratatui::{prelude::*, widgets::*};
-
-fn main() -> io::Result<()> {
-    enable_raw_mode()?;
-    stdout().execute(EnterAlternateScreen)?;
-    let mut terminal = Terminal::new(CrosstermBackend::new(stdout()))?;
-
-    let mut should_quit = false;
-    while !should_quit {
-        terminal.draw(ui)?;
-        should_quit = handle_events()?;
-    }
-
-    disable_raw_mode()?;
-    stdout().execute(LeaveAlternateScreen)?;
-    Ok(())
+fn main() -> Result<()> {
+    color_eyre::install()?;
+    let terminal = ratatui::init();
+    let result = run(terminal);
+    ratatui::restore();
+    result
 }
 
-fn handle_events() -> io::Result<bool> {
-    if event::poll(std::time::Duration::from_millis(50))? {
-        if let Event::Key(key) = event::read()? {
-            if key.kind == event::KeyEventKind::Press && key.code == KeyCode::Char('q') {
-                return Ok(true);
-            }
+fn run(mut terminal: DefaultTerminal) -> Result<()> {
+    loop {
+        terminal.draw(render)?;
+        if matches!(event::read()?, Event::Key(_)) {
+            break Ok(());
         }
     }
-    Ok(false)
 }
 
-fn ui(frame: &mut Frame) {
-    frame.render_widget(
-        Paragraph::new("Hello World!")
-            .block(Block::bordered().title("Greeting")),
-        frame.size(),
-    );
+fn render(frame: &mut Frame) {
+    frame.render_widget("hello world", frame.area());
 }
 ```
 
-Running this example produces the following output:
+## Documentation
 
-![docsrs-hello]
+- [Docs] - the full API documentation for the library on docs.rs.
+- [Ratatui Website] - explains the library's concepts and provides step-by-step tutorials.
+- [Ratatui Forum] - a place to ask questions and discuss the library.
+- [Widget Examples] - a collection of examples that demonstrate how to use the library.
+- [App Examples] - a collection of more complex examples that demonstrate how to build apps.
+- [ARCHITECTURE.md] - explains the crate organization and modular workspace structure.
+- [Changelog] - generated by [git-cliff] utilizing [Conventional Commits].
+- [Breaking Changes] - a list of breaking changes in the library.
 
-## Layout
+You can also watch the [EuroRust 2024 talk] to learn about common concepts in Ratatui and what's
+possible to build with it.
 
-The library comes with a basic yet useful layout management object called [`Layout`] which
-allows you to split the available space into multiple areas and then render widgets in each
-area. This lets you describe a responsive terminal UI by nesting layouts. See the [Layout]
-section of the [Ratatui Website] for more info.
+## Templates
 
-```rust
-use ratatui::{prelude::*, widgets::*};
+If you're looking to get started quickly, you can use one of the available templates from the
+[templates] repository using [`cargo-generate`]:
 
-fn ui(frame: &mut Frame) {
-    let main_layout = Layout::new(
-        Direction::Vertical,
-        [
-            Constraint::Length(1),
-            Constraint::Min(0),
-            Constraint::Length(1),
-        ],
-    )
-    .split(frame.size());
-    frame.render_widget(
-        Block::new().borders(Borders::TOP).title("Title Bar"),
-        main_layout[0],
-    );
-    frame.render_widget(
-        Block::new().borders(Borders::TOP).title("Status Bar"),
-        main_layout[2],
-    );
-
-    let inner_layout = Layout::new(
-        Direction::Horizontal,
-        [Constraint::Percentage(50), Constraint::Percentage(50)],
-    )
-    .split(main_layout[1]);
-    frame.render_widget(
-        Block::bordered().title("Left"),
-        inner_layout[0],
-    );
-    frame.render_widget(
-        Block::bordered().title("Right"),
-        inner_layout[1],
-    );
-}
+```shell
+cargo generate ratatui/templates
 ```
 
-Running this example produces the following output:
+## Built with Ratatui
 
-![docsrs-layout]
+[![Awesome](https://awesome.re/badge-flat2.svg)][awesome-ratatui]
 
-## Text and styling
-
-The [`Text`], [`Line`] and [`Span`] types are the building blocks of the library and are used in
-many places. [`Text`] is a list of [`Line`]s and a [`Line`] is a list of [`Span`]s. A [`Span`]
-is a string with a specific style.
-
-The [`style` module] provides types that represent the various styling options. The most
-important one is [`Style`] which represents the foreground and background colors and the text
-attributes of a [`Span`]. The [`style` module] also provides a [`Stylize`] trait that allows
-short-hand syntax to apply a style to widgets and text. See the [Styling Text] section of the
-[Ratatui Website] for more info.
-
-```rust
-use ratatui::{prelude::*, widgets::*};
-
-fn ui(frame: &mut Frame) {
-    let areas = Layout::new(
-        Direction::Vertical,
-        [
-            Constraint::Length(1),
-            Constraint::Length(1),
-            Constraint::Length(1),
-            Constraint::Length(1),
-            Constraint::Min(0),
-        ],
-    )
-    .split(frame.size());
-
-    let span1 = Span::raw("Hello ");
-    let span2 = Span::styled(
-        "World",
-        Style::new()
-            .fg(Color::Green)
-            .bg(Color::White)
-            .add_modifier(Modifier::BOLD),
-    );
-    let span3 = "!".red().on_light_yellow().italic();
-
-    let line = Line::from(vec![span1, span2, span3]);
-    let text: Text = Text::from(vec![line]);
-
-    frame.render_widget(Paragraph::new(text), areas[0]);
-    // or using the short-hand syntax and implicit conversions
-    frame.render_widget(
-        Paragraph::new("Hello World!".red().on_white().bold()),
-        areas[1],
-    );
-
-    // to style the whole widget instead of just the text
-    frame.render_widget(
-        Paragraph::new("Hello World!").style(Style::new().red().on_white()),
-        areas[2],
-    );
-    // or using the short-hand syntax
-    frame.render_widget(Paragraph::new("Hello World!").blue().on_yellow(), areas[3]);
-}
-```
-
-Running this example produces the following output:
-
-![docsrs-styling]
-
-[Ratatui Website]: https://ratatui.rs/
-[Installation]: https://ratatui.rs/installation/
-[Rendering]: https://ratatui.rs/concepts/rendering/
-[Application Patterns]: https://ratatui.rs/concepts/application-patterns/
-[Hello World tutorial]: https://ratatui.rs/tutorials/hello-world/
-[Backends]: https://ratatui.rs/concepts/backends/
-[Widgets]: https://ratatui.rs/how-to/widgets/
-[Handling Events]: https://ratatui.rs/concepts/event-handling/
-[Layout]: https://ratatui.rs/how-to/layout/
-[Styling Text]: https://ratatui.rs/how-to/render/style-text/
-[templates]: https://github.com/ratatui-org/templates/
-[Examples]: https://github.com/ratatui-org/ratatui/tree/main/examples/README.md
-[Report a bug]: https://github.com/ratatui-org/ratatui/issues/new?labels=bug&projects=&template=bug_report.md
-[Request a Feature]: https://github.com/ratatui-org/ratatui/issues/new?labels=enhancement&projects=&template=feature_request.md
-[Create a Pull Request]: https://github.com/ratatui-org/ratatui/compare
-[git-cliff]: https://git-cliff.org
-[Conventional Commits]: https://www.conventionalcommits.org
-[API Docs]: https://docs.rs/ratatui
-[Changelog]: https://github.com/ratatui-org/ratatui/blob/main/CHANGELOG.md
-[Contributing]: https://github.com/ratatui-org/ratatui/blob/main/CONTRIBUTING.md
-[Breaking Changes]: https://github.com/ratatui-org/ratatui/blob/main/BREAKING-CHANGES.md
-[FOSDEM 2024 talk]: https://www.youtube.com/watch?v=NU0q6NOLJ20
-[docsrs-hello]: https://github.com/ratatui-org/ratatui/blob/c3c3c289b1eb8d562afb1931adb4dc719cd48490/examples/docsrs-hello.png?raw=true
-[docsrs-layout]: https://github.com/ratatui-org/ratatui/blob/c3c3c289b1eb8d562afb1931adb4dc719cd48490/examples/docsrs-layout.png?raw=true
-[docsrs-styling]: https://github.com/ratatui-org/ratatui/blob/c3c3c289b1eb8d562afb1931adb4dc719cd48490/examples/docsrs-styling.png?raw=true
-[`Frame`]: terminal::Frame
-[`render_widget`]: terminal::Frame::render_widget
-[`Widget`]: widgets::Widget
-[`Layout`]: layout::Layout
-[`Text`]: text::Text
-[`Line`]: text::Line
-[`Span`]: text::Span
-[`Style`]: style::Style
-[`style` module]: style
-[`Stylize`]: style::Stylize
-[`Backend`]: backend::Backend
-[`backend` module]: backend
-[`crossterm::event`]: https://docs.rs/crossterm/latest/crossterm/event/index.html
-[Crate]: https://crates.io/crates/ratatui
-[Crossterm]: https://crates.io/crates/crossterm
-[Termion]: https://crates.io/crates/termion
-[Termwiz]: https://crates.io/crates/termwiz
-[tui-rs]: https://crates.io/crates/tui
-[GitHub Sponsors]: https://github.com/sponsors/ratatui-org
-[Crate Badge]: https://img.shields.io/crates/v/ratatui?logo=rust&style=flat-square&logoColor=E05D44&color=E05D44
-[License Badge]: https://img.shields.io/crates/l/ratatui?style=flat-square&color=1370D3
-[CI Badge]: https://img.shields.io/github/actions/workflow/status/ratatui-org/ratatui/ci.yml?style=flat-square&logo=github
-[CI Workflow]: https://github.com/ratatui-org/ratatui/actions/workflows/ci.yml
-[Codecov Badge]:
-    https://img.shields.io/codecov/c/github/ratatui-org/ratatui?logo=codecov&style=flat-square&token=BAQ8SOKEST&color=C43AC3&logoColor=C43AC3
-[Codecov]: https://app.codecov.io/gh/ratatui-org/ratatui
-[Deps.rs Badge]: https://deps.rs/repo/github/ratatui-org/ratatui/status.svg?style=flat-square
-[Deps.rs]: https://deps.rs/repo/github/ratatui-org/ratatui
-[Discord Badge]:
-    https://img.shields.io/discord/1070692720437383208?label=discord&logo=discord&style=flat-square&color=1370D3&logoColor=1370D3
-[Discord Server]: https://discord.gg/pMCEU9hNEj
-[Docs Badge]: https://img.shields.io/docsrs/ratatui?logo=rust&style=flat-square&logoColor=E05D44
-[Matrix Badge]:
-    https://img.shields.io/matrix/ratatui-general%3Amatrix.org?style=flat-square&logo=matrix&label=Matrix&color=C43AC3
-[Matrix]: https://matrix.to/#/#ratatui:matrix.org
-[Sponsors Badge]: https://img.shields.io/github/sponsors/ratatui-org?logo=github&style=flat-square&color=1370D3
-
-<!-- cargo-rdme end -->
-
-## Status of this fork
-
-In response to the original maintainer [**Florian Dehau**](https://github.com/fdehau)'s issue
-regarding the [future of `tui-rs`](https://github.com/fdehau/tui-rs/issues/654), several members of
-the community forked the project and created this crate. We look forward to continuing the work
-started by Florian 🚀
-
-In order to organize ourselves, we currently use a [Discord server](https://discord.gg/pMCEU9hNEj),
-feel free to join and come chat! There is also a [Matrix](https://matrix.org/) bridge available at
-[#ratatui:matrix.org](https://matrix.to/#/#ratatui:matrix.org).
-
-While we do utilize Discord for coordinating, it's not essential for contributing.
-Our primary open-source workflow is centered around GitHub.
-For significant discussions, we rely on GitHub — please open an issue, a discussion or a PR.
-
-Please make sure you read the updated [contributing](./CONTRIBUTING.md) guidelines, especially if
-you are interested in working on a PR or issue opened in the previous repository.
-
-## Rust version requirements
-
-Since version 0.23.0, The Minimum Supported Rust Version (MSRV) of `ratatui` is 1.67.0.
-
-## Widgets
-
-### Built in
-
-The library comes with the following
-[widgets](https://docs.rs/ratatui/latest/ratatui/widgets/index.html):
-
-- [BarChart](https://docs.rs/ratatui/latest/ratatui/widgets/struct.BarChart.html)
-- [Block](https://docs.rs/ratatui/latest/ratatui/widgets/block/struct.Block.html)
-- [Calendar](https://docs.rs/ratatui/latest/ratatui/widgets/calendar/index.html)
-- [Canvas](https://docs.rs/ratatui/latest/ratatui/widgets/canvas/struct.Canvas.html) which allows
-  rendering [points, lines, shapes and a world
-  map](https://docs.rs/ratatui/latest/ratatui/widgets/canvas/index.html)
-- [Chart](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Chart.html)
-- [Clear](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Clear.html)
-- [Gauge](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Gauge.html)
-- [List](https://docs.rs/ratatui/latest/ratatui/widgets/struct.List.html)
-- [Paragraph](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Paragraph.html)
-- [Scrollbar](https://docs.rs/ratatui/latest/ratatui/widgets/scrollbar/struct.Scrollbar.html)
-- [Sparkline](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Sparkline.html)
-- [Table](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Table.html)
-- [Tabs](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Tabs.html)
-
-Each widget has an associated example which can be found in the [Examples] folder. Run each example
-with cargo (e.g. to run the gauge example `cargo run --example gauge`), and quit by pressing `q`.
-
-You can also run all examples by running `cargo make run-examples` (requires `cargo-make` that can
-be installed with `cargo install cargo-make`).
-
-### Third-party libraries, bootstrapping templates and widgets
-
-- [ansi-to-tui](https://github.com/uttarayan21/ansi-to-tui) — Convert ansi colored text to
-  `ratatui::text::Text`
-- [color-to-tui](https://github.com/uttarayan21/color-to-tui) — Parse hex colors to
-  `ratatui::style::Color`
-- [templates](https://github.com/ratatui-org/templates) — Starter templates for
-  bootstrapping a Rust TUI application with Ratatui & crossterm
-- [tui-builder](https://github.com/jkelleyrtp/tui-builder) — Batteries-included MVC framework for
-  Tui-rs + Crossterm apps
-- [tui-clap](https://github.com/kegesch/tui-clap-rs) — Use clap-rs together with Tui-rs
-- [tui-log](https://github.com/kegesch/tui-log-rs) — Example of how to use logging with Tui-rs
-- [tui-logger](https://github.com/gin66/tui-logger) — Logger and Widget for Tui-rs
-- [tui-realm](https://github.com/veeso/tui-realm) — Tui-rs framework to build stateful applications
-  with a React/Elm inspired approach
-- [tui-realm-treeview](https://github.com/veeso/tui-realm-treeview) — Treeview component for
-  Tui-realm
-- [tui-rs-tree-widgets](https://github.com/EdJoPaTo/tui-rs-tree-widget) — Widget for tree data
-  structures.
-- [tui-windows](https://github.com/markatk/tui-windows-rs) — Tui-rs abstraction to handle multiple
-  windows and their rendering
-- [tui-textarea](https://github.com/rhysd/tui-textarea) — Simple yet powerful multi-line text editor
-  widget supporting several key shortcuts, undo/redo, text search, etc.
-- [tui-input](https://github.com/sayanarijit/tui-input) — TUI input library supporting multiple
-  backends and tui-rs.
-- [tui-term](https://github.com/a-kenji/tui-term) — A pseudoterminal widget library
-  that enables the rendering of terminal applications as ratatui widgets.
-
-## Apps
-
-Check out [awesome-ratatui](https://github.com/ratatui-org/awesome-ratatui) for a curated list of
-awesome apps/libraries built with `ratatui`!
+Check out the [showcase] section of the website, or the [awesome-ratatui] repository for a curated
+list of awesome apps and libraries built with Ratatui!
 
 ## Alternatives
 
-You might want to checkout [Cursive](https://github.com/gyscos/Cursive) for an alternative solution
-to build text user interfaces in Rust.
+- [Cursive](https://crates.io/crates/cursive) - a ncurses-based TUI library.
+- [iocraft](https://crates.io/crates/iocraft) - a declarative TUI library.
 
-## Acknowledgments
+## Contributing
 
-Special thanks to [**Pavel Fomchenkov**](https://github.com/nawok) for his work in designing **an
-awesome logo** for the ratatui project and ratatui-org organization.
+[![Discord Badge]][Discord Server] [![Matrix Badge]][Matrix] [![Forum Badge]][Ratatui Forum]
+
+Feel free to join our [Discord server](https://discord.gg/pMCEU9hNEj) for discussions and questions!
+There is also a [Matrix](https://matrix.org/) bridge available at
+[#ratatui:matrix.org](https://matrix.to/#/#ratatui:matrix.org). We have also recently launched the
+[Ratatui Forum].
+
+We rely on GitHub for [bugs][Report a bug] and [feature requests][Request a Feature].
+
+Please make sure you read the [contributing](./CONTRIBUTING.md) guidelines before [creating a pull
+request][Create a Pull Request]. We accept AI generated code, but please read the [AI Contributions]
+guidelines to ensure compliance.
+
+If you'd like to show your support, you can add the Ratatui badge to your project's README:
+
+```md
+[![Built With Ratatui](https://img.shields.io/badge/Built_With_Ratatui-000?logo=ratatui&logoColor=fff)](https://ratatui.rs/)
+```
+
+[![Built With Ratatui](https://img.shields.io/badge/Built_With_Ratatui-000?logo=ratatui&logoColor=fff)](https://ratatui.rs/)
+
+## Acknowledgements
+
+Ratatui was forked from the [tui-rs] crate in 2023 in order to continue its development. None of
+this could be possible without [Florian Dehau] who originally created [tui-rs] which inspired many
+Rust TUIs.
+
+Special thanks to [Pavel Fomchenkov] for his work in designing an awesome logo for the Ratatui
+project and organization.
 
 ## License
 
-[MIT](./LICENSE)
+This project is licensed under the [MIT License][License].
+
+[Repo]: https://github.com/ratatui/ratatui
+[Ratatui Website]: https://ratatui.rs/
+[Ratatui Forum]: https://forum.ratatui.rs
+[Docs]: https://docs.rs/ratatui
+[Widget Examples]: https://github.com/ratatui/ratatui/tree/main/ratatui-widgets/examples
+[App Examples]: https://github.com/ratatui/ratatui/tree/main/examples
+[ARCHITECTURE.md]: https://github.com/ratatui/ratatui/blob/main/ARCHITECTURE.md
+[Changelog]: https://github.com/ratatui/ratatui/blob/main/CHANGELOG.md
+[git-cliff]: https://git-cliff.org
+[Conventional Commits]: https://www.conventionalcommits.org
+[Breaking Changes]: https://github.com/ratatui/ratatui/blob/main/BREAKING-CHANGES.md
+[EuroRust 2024 talk]: https://www.youtube.com/watch?v=hWG51Mc1DlM
+[Report a bug]: https://github.com/ratatui/ratatui/issues/new?labels=bug&projects=&template=bug_report.md
+[Request a Feature]: https://github.com/ratatui/ratatui/issues/new?labels=enhancement&projects=&template=feature_request.md
+[Create a Pull Request]: https://github.com/ratatui/ratatui/compare
+[Contributing]: https://github.com/ratatui/ratatui/blob/main/CONTRIBUTING.md
+[AI Contributions]: https://github.com/ratatui/ratatui/blob/main/CONTRIBUTING.md#ai-generated-content
+[Crate]: https://crates.io/crates/ratatui
+[tui-rs]: https://crates.io/crates/tui
+[Sponsors]: https://github.com/sponsors/ratatui
+[Crate Badge]: https://img.shields.io/crates/v/ratatui?logo=rust&style=flat-square&color=E05D44
+[Repo Badge]: https://img.shields.io/badge/repo-ratatui/ratatui-1370D3?style=flat-square&logo=github
+[License Badge]: https://img.shields.io/crates/l/ratatui?style=flat-square&color=1370D3
+[CI Badge]: https://img.shields.io/github/actions/workflow/status/ratatui/ratatui/ci.yml?style=flat-square&logo=github
+[CI]: https://github.com/ratatui/ratatui/actions/workflows/ci.yml
+[Codecov Badge]: https://img.shields.io/codecov/c/github/ratatui/ratatui?logo=codecov&style=flat-square&token=BAQ8SOKEST&color=C43AC3
+[Codecov]: https://app.codecov.io/gh/ratatui/ratatui
+[Deps Badge]: https://deps.rs/repo/github/ratatui/ratatui/status.svg?path=ratatui&style=flat-square
+[Deps]: https://deps.rs/repo/github/ratatui/ratatui?path=ratatui
+[Discord Badge]: https://img.shields.io/discord/1070692720437383208?label=discord&logo=discord&style=flat-square&color=1370D3&logoColor=1370D3
+[Discord Server]: https://discord.gg/pMCEU9hNEj
+[Docs Badge]: https://img.shields.io/badge/docs-ratatui-1370D3?style=flat-square&logo=rust
+[Matrix Badge]: https://img.shields.io/matrix/ratatui-general%3Amatrix.org?style=flat-square&logo=matrix&label=Matrix&color=C43AC3
+[Matrix]: https://matrix.to/#/#ratatui:matrix.org
+[Forum Badge]: https://img.shields.io/discourse/likes?server=https%3A%2F%2Fforum.ratatui.rs&style=flat-square&logo=discourse&label=forum&color=C43AC3
+[Sponsors Badge]: https://img.shields.io/github/sponsors/ratatui?logo=github&style=flat-square&color=1370D3
+[templates]: https://github.com/ratatui/templates/
+[showcase]: https://ratatui.rs/showcase/
+[awesome-ratatui]: https://github.com/ratatui/awesome-ratatui
+[Pavel Fomchenkov]: https://github.com/nawok
+[Florian Dehau]: https://github.com/fdehau
+[`cargo-generate`]: https://crates.io/crates/cargo-generate
+[License]: ./LICENSE

RELEASE.md

@@ -1,5 +1,12 @@
 # Creating a Release
 
+Our release strategy is:
+
+> Release major versions with detailed summaries when necessary, while releasing minor versions
+> weekly or as needed without extensive announcements.
+>
+> Versioning scheme being `0.x.y`, where `x` is the major version and `y` is the minor version.
+
 [crates.io](https://crates.io/crates/ratatui) releases are automated via [GitHub
 actions](.github/workflows/cd.yml) and triggered by pushing a tag.
 
@@ -12,7 +19,7 @@ actions](.github/workflows/cd.yml) and triggered by pushing a tag.
    ```
 
 1. Switch branches to the images branch and copy demo2.gif to examples/, commit, and push.
-1. Grab the permalink from <https://github.com/ratatui-org/ratatui/blob/images/examples/demo2.gif> and
+1. Grab the permalink from <https://github.com/ratatui/ratatui/blob/images/examples/demo2.gif> and
    append `?raw=true` to redirect to the actual image url. Then update the link in the main README.
    Avoid adding the gif to the git repo as binary files tend to bloat repositories.
 
@@ -21,16 +28,16 @@ actions](.github/workflows/cd.yml) and triggered by pushing a tag.
    can be used for generating the entries.
 1. Ensure that any breaking changes are documented in [BREAKING-CHANGES.md](./BREAKING-CHANGES.md)
 1. Commit and push the changes.
-1. Create a new tag: `git tag -a v[X.Y.Z]`
+1. Create a new tag: `git tag -a v[0.x.y]`
 1. Push the tag: `git push --tags`
-1. Wait for [Continuous Deployment](https://github.com/ratatui-org/ratatui/actions) workflow to
+1. Wait for [Continuous Deployment](https://github.com/ratatui/ratatui/actions) workflow to
    finish.
 
 ## Alpha Releases
 
 Alpha releases are automatically released every Saturday via [cd.yml](./.github/workflows/cd.yml)
-and can be manually be created when necessary by triggering the [Continuous
-Deployment](https://github.com/ratatui-org/ratatui/actions/workflows/cd.yml) workflow.
+and can be manually created when necessary by triggering the [Continuous
+Deployment](https://github.com/ratatui/ratatui/actions/workflows/cd.yml) workflow.
 
 We automatically release an alpha release with a patch level bump + alpha.num weekly (and when we
 need to manually). E.g. the last release was 0.22.0, and the most recent alpha release is
@@ -40,5 +47,5 @@ These releases will have whatever happened to be in main at the time of release,
 for apps that need to get releases from crates.io, but may contain more bugs and be generally less
 tested than normal releases.
 
-See [#147](https://github.com/ratatui-org/ratatui/issues/147) and
-[#359](https://github.com/ratatui-org/ratatui/pull/359) for more info on the alpha release process.
+See [#147](https://github.com/ratatui/ratatui/issues/147) and
+[#359](https://github.com/ratatui/ratatui/pull/359) for more info on the alpha release process.

SECURITY.md

@@ -6,4 +6,4 @@ We only support the latest version of this crate.
 
 ## Reporting a Vulnerability
 
-To report secuirity vulnerability, please use the form at https://github.com/ratatui-org/ratatui/security/advisories/new
+To report secuirity vulnerability, please use the form at <https://github.com/ratatui/ratatui/security/advisories/new>

assets/logo-simple.svg

@@ -0,0 +1 @@
+<svg role="img" viewBox="0 0 50 50" xmlns="http://www.w3.org/2000/svg"><title>Ratatui</title><path d="M17 29h1v1h1v1h1v1h1v1h1v1h1v1h1v1h1v1h1v1h1v1h1v1h1v1h1v1h1v1h1v1h1v1h1v1h1v1h1v1h1v1h1v1H5v-1H4v-1H3v-1H2v-1H1v-1H0v-2h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h2zm-2 14h1v1h1v1h1v-2h-1v-1h-1v-1h-1zm0-6h-3v1h1v1h4v-4h-1v-1h-1zm35-21h-1v4h-1v1h-1v1h-1v1h-2v1h-1v1h-1v1h-1v1h-2v9h5v1h1v9h-1v1h-1v2h-1v1h-1v-1h-1v-1h-1v-1h1v-1h1v-1h1v-5h-1v1h-3v1h-1v3h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-2h1v-2h1v-1h-2v1h-4v-1h-1v-1h-1v-1h-1v-2h1v-1h1v-1h2v-1h7v-1h1v-1h1v-1h1v-1h1v-1h1v-1h4v-1h3v-1h10zm-17 2h-1v2h1v1h2v-1h1v-2h-1v-1h-2zM29 1h1v9h1v1h1v2h1v2h-1v1h-1v1h-1v1h-1v1h-1v1h-3v-1h-1v-1h-2v-1h-1v-1h-1v-1h-6v-1h-1V9h1V8h1V7h1V6h1V5h1V4h1V3h1V2h1V1h2V0h6z"/></svg>

assets/logo.svg

@@ -0,0 +1 @@
+<svg role="img" viewBox="0 0 50 50" xmlns="http://www.w3.org/2000/svg"><title>Ratatui</title><path d="M50 16h-1v4h-1v1h-1v1h-1v1h-2v1h-1v1h-1v1h-1v1h-2v9h5v1h1v9h-1v1h-1v2h-1v1h-1v-1h-1v1h-2v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-1v-1h-2v1h-1v1h-1v1h-1v1h-1v1h-1v1h-1v1H9v1H8v1H7v1H6v1H5v1H4v1H3v1H2v2h1v1h1v1h1v1h1v1h1v1H5v-1H4v-1H3v-1H2v-1H1v-1H0v-2h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h1v-1h2v1h1v-1h-1v-1h-1v-2h1v-1h1v-1h2v-1h7v-1h1v-1h1v-1h1v-1h1v-1h1v-1h4v-1h3v-1h10zM39 49h1v-1h-1zm2-8h-3v1h-1v3h-1v-1h-1v1h1v1h1v1h1v1h1v-1h1v-1h1v-1h1v-5h-1zm-7 3h1v-1h-1zm-1-1h1v-1h-1zm-1-1h1v-1h-1zm-1-1h1v-1h-1zm-1-1h1v-1h-1zm-1-1h1v-1h-1zm-1-1h1v-1h-1zm-1-1h1v-1h-1zm-1-1h1v-1h-1zm-1-1h1v-1h-1zm-1-1h1v-1h-1zm-5-5h1v1h1v1h1v1h1v1h1v-2h1v-2h1v-1h-2v1h-4v-1h-1zm14-11h-1v2h1v1h2v-1h1v-2h-1v-1h-2zM18 40h1v1h1v2h-1v-1h-1v-1h-1v-2h1zm0-7h1v4h-4v-1h-1v-1h3v-3h1zM29 1h1v9h1v1h1v2h1v2h-1v1h-1v1h-1v1h-1v1h-1v1h-3v-1h-1v-1h-2v-1h-1v-1h-1v-1h-6v-1h-1V9h1V8h1V7h1V6h1V5h1V4h1V3h1V2h1V1h2V0h6z"/></svg>

bacon.toml

@@ -8,101 +8,80 @@
 default_job = "check"
 
 [jobs.check]
-command = ["cargo", "check", "--all-features", "--color", "always"]
+command = ["cargo", "xtask", "check"]
 need_stdout = false
 
 [jobs.check-all]
-command = ["cargo", "check", "--all-targets", "--all-features", "--color", "always"]
+command = ["cargo", "xtask", "check", "--all-features"]
 need_stdout = false
 
 [jobs.check-crossterm]
-command = ["cargo", "check", "--color", "always", "--all-targets", "--no-default-features", "--features", "crossterm"]
+command = ["cargo", "xtask", "check-backend", "crossterm"]
 need_stdout = false
 
 [jobs.check-termion]
-command = ["cargo", "check", "--color", "always", "--all-targets", "--no-default-features", "--features", "termion"]
+command = ["cargo", "xtask", "check-backend", "termion"]
 need_stdout = false
 
 [jobs.check-termwiz]
-command = ["cargo", "check", "--color", "always", "--all-targets", "--no-default-features", "--features", "termwiz"]
+command = ["cargo", "xtask", "check-backend", "termwiz"]
 need_stdout = false
 
-[jobs.clippy]
-command = [
-    "cargo", "clippy",
-    "--all-targets",
-    "--color", "always",
-]
+[jobs.clippy-all]
+command = ["cargo", "xtask", "clippy"]
 need_stdout = false
 
 [jobs.test]
-command = [
-    "cargo", "test",
-    "--all-features",
-    "--color", "always",
-    "--", "--color", "always", # see https://github.com/Canop/bacon/issues/124
-]
+command = ["cargo", "xtask", "test"]
 need_stdout = true
 
 [jobs.test-unit]
-command = [
-    "cargo", "test",
-    "--lib",
-    "--all-features",
-    "--color", "always",
-    "--", "--color", "always", # see https://github.com/Canop/bacon/issues/124
-]
+command = ["cargo", "xtask", "test-libs"]
 need_stdout = true
 
 [jobs.doc]
-command = [
-    "cargo", "+nightly", "doc",
-    "-Zunstable-options", "-Zrustdoc-scrape-examples",
-    "--all-features",
-    "--color", "always",
-    "--no-deps",
-]
-env.RUSTDOCFLAGS = "--cfg docsrs"
+command = ["cargo", "xtask", "docs"]
 need_stdout = false
 
-# If the doc compiles, then it opens in your browser and bacon switches
-# to the previous job
 [jobs.doc-open]
-command = [
-    "cargo", "+nightly", "doc",
-    "-Zunstable-options", "-Zrustdoc-scrape-examples",
-    "--all-features",
-    "--color", "always",
-    "--no-deps",
-    "--open",
-]
-env.RUSTDOCFLAGS = "--cfg docsrs"
+command = ["cargo", "xtask", "docs", "--open"]
+on_success = "job:doc"
 need_stdout = false
-on_success = "job:doc" # so that we don't open the browser at each change
 
 [jobs.coverage]
-command = [
-    "cargo", "llvm-cov",
-    "--lcov", "--output-path", "target/lcov.info",
-    "--all-features",
-    "--color", "always",
-]
+command = ["cargo", "xtask", "coverage"]
 
 [jobs.coverage-unit-tests-only]
-command = [
-    "cargo", "llvm-cov",
-    "--lcov", "--output-path", "target/lcov.info",
-    "--lib",
-    "--all-features",
-    "--color", "always",
-]
+command = ["cargo", "xtask", "coverage", "--lib"]
+
+[jobs.hack]
+command = ["cargo", "xtask", "hack"]
+
+[jobs.format]
+command = ["cargo", "xtask", "format"]
+
+[jobs.zizmor-offline]
+# zizmor checks the workflow files for security issues. The offline version is generally faster, but
+# checks for fewer issues.
+command = ["zizmor", "--color", "always", ".github/workflows", "--offline"]
+need_stdout = true
+default_watch = false
+watch = [".github/workflows/"]
+
+[jobs.zizmor-online]
+# zizmor checks the workflow files for security issues. The online version is a bit slower, but it
+# checks for more issues
+command = ["zizmor", "--color", "always", ".github/workflows"]
+need_stdout = true
+default_watch = false
+watch = [".github/workflows/"]
 
 # You may define here keybindings that would be specific to
 # a project, for example a shortcut to launch a specific job.
 # Shortcuts to internal functions (scrolling, toggling, etc.)
 # should go in your personal global prefs.toml file instead.
 [keybindings]
-# alt-m = "job:my-job"
+ctrl-h = "job:hack"
 ctrl-c = "job:check-crossterm"
 ctrl-t = "job:check-termion"
 ctrl-w = "job:check-termwiz"
@@ -110,3 +89,6 @@ v = "job:coverage"
 ctrl-v = "job:coverage-unit-tests-only"
 u = "job:test-unit"
 n = "job:nextest"
+f = "job:format"
+z = "job:zizmor-offline"
+shift-z = "job:zizmor-online"

cliff.toml

@@ -2,7 +2,7 @@
 # https://git-cliff.org/docs/configuration
 
 [remote.github]
-owner = "ratatui-org"
+owner = "ratatui"
 repo = "ratatui"
 
 [changelog]
@@ -11,6 +11,8 @@ header = """
 # Changelog
 
 All notable changes to this project will be documented in this file.
+<!-- ignore lint rules that are often triggered by content generated from commits / git-cliff -->
+<!-- markdownlint-disable line-length no-bare-urls ul-style emphasis-style -->
 """
 # template for the changelog body
 # https://keats.github.io/tera/docs/#introduction
@@ -22,25 +24,27 @@ body = """
 {%- if not version %}
 ## [unreleased]
 {% else -%}
-## [{{ version }}](https://github.com/ratatui-org/ratatui/releases/tag/{{ version }}) - {{ timestamp | date(format="%Y-%m-%d") }}
+{%- if package -%} {# release-plz specific variable #}
+## {{ package }} - [{{ version }}]({{ release_link }}) - {{ timestamp | date(format="%Y-%m-%d") }}
+{%- else -%}
+## [{{ version }}]({{ self::remote_url() }}/releases/tag/{{ version }}) - {{ timestamp | date(format="%Y-%m-%d") }}
+{%- endif %}
 {% endif -%}
 
 {% macro commit(commit) -%}
-- [{{ commit.id | truncate(length=7, end="") }}]({{ "https://github.com/ratatui-org/ratatui/commit/" ~ commit.id }})
+- [{{ commit.id | truncate(length=7, end="") }}]({{ "https://github.com/ratatui/ratatui/commit/" ~ commit.id }}) \
   *({{commit.scope | default(value = "uncategorized") | lower }})* {{ commit.message | upper_first | trim }}\
-  {% if commit.github.username %} by @{{ commit.github.username }}{%- endif -%}\
-  {% if commit.github.pr_number %} in [#{{ commit.github.pr_number }}]({{ self::remote_url() }}/pull/{{ commit.github.pr_number }}){%- endif %}\
+  {% if commit.remote.username %} by @{{ commit.remote.username }}{%- endif -%}\
+  {% if commit.remote.pr_number %} in [#{{ commit.remote.pr_number }}]({{ self::remote_url() }}/pull/{{ commit.remote.pr_number }}){%- endif %}\
 {%- if commit.breaking %} [**breaking**]{% endif %}
-{%- if commit.body %}
-
-  ````text {#- 4 backticks escape any backticks in body #}
-  {{commit.body | indent(prefix="  ") }}
-  ````
+{%- if commit.body %}\n\n{{ commit.body | indent(prefix="  > ", first=true, blank=true) }}
 {%- endif %}
-{%- for footer in commit.footers %}
+{%- for footer in commit.footers %}\n
 {%- if footer.token != "Signed-off-by" and footer.token != "Co-authored-by" %}
-
-  {{ footer.token | indent(prefix="  ") }}{{ footer.separator }}{{ footer.value }}
+  >
+{{ footer.token | indent(prefix="  > ", first=true, blank=true) }}
+{{- footer.separator }}
+{{- footer.value| indent(prefix="  > ", first=false, blank=true)  }}
 {%- endif %}
 {%- endfor %}
 {% endmacro -%}
@@ -57,6 +61,7 @@ body = """
 {%- endfor -%}
 {%- endfor %}
 
+{%- if not release_link -%}
 {% if github.contributors | filter(attribute="is_first_time", value=true) | length != 0 %}
 ### New Contributors
 {%- endif %}\
@@ -66,27 +71,36 @@ body = """
 [#{{ contributor.pr_number }}]({{ self::remote_url() }}/pull/{{ contributor.pr_number }}) \
 {%- endif %}
 {%- endfor -%}
+{%- endif -%}
 
 {% if version %}
 {% if previous.version %}
+{%- if release_link -%}
+**Full Changelog**: {{ release_link }} {# release-plz specific variable #}
+{%- else -%}
 **Full Changelog**: {{ self::remote_url() }}/compare/{{ previous.version }}...{{ version }}
 {% endif %}
+{% endif %}
 {% else -%}
   {% raw %}\n{% endraw %}
 {% endif %}
 
 {%- macro remote_url() -%}
+{%- if remote.owner -%} {# release-plz specific variable #}
+https://github.com/{{ remote.owner }}/{{ remote.repo }}\
+{%- else -%}
 https://github.com/{{ remote.github.owner }}/{{ remote.github.repo }}\
+{%- endif -%}
 {% endmacro %}
 """
-
-
 # remove the leading and trailing whitespace from the template
 trim = false
-# changelog footer
-footer = """
-<!-- generated by git-cliff -->
-"""
+# postprocessors for the changelog body
+postprocessors = [
+  { pattern = '<!-- Please read CONTRIBUTING.md before submitting any pull request. -->', replace = "" },
+  { pattern = '>---+\n', replace = '' },
+  { pattern = ' +\n', replace = "\n" },
+]
 
 [git]
 # parse the commits based on https://www.conventionalcommits.org
@@ -102,9 +116,21 @@ commit_preprocessors = [
   { pattern = '(Clarify README.md)', replace = "docs(readme): ${1}" },
   { pattern = '(Update README.md)', replace = "docs(readme): ${1}" },
   { pattern = '(fix typos|Fix typos)', replace = "fix: ${1}" },
+  # Typos that squeaked through and which would otherwise trigger the typos linter.
+  # Regex obsfucation is to avoid triggering the linter in this file until there's a per file config
+  # See https://github.com/crate-ci/typos/issues/724
+  { pattern = '\<[d]eatil\>', replace = "detail" },
+  { pattern = '\<[f]eatuers\>', replace = "features" },
+  { pattern = '\<[s]pecically\>', replace = "specially" },
+  { pattern = '\<[g]ague\>', replace = "gauge" },
+  { pattern = '\<[a]rithmentic\>', replace = "arithmetic" },
+  { pattern = '\<[i]ntructions\>', replace = "instructions" },
+  { pattern = '\<[i]mplementated\>', replace = "implemented" },
 ]
 # regex for parsing and grouping commits
 commit_parsers = [
+  # release-plz adds 000000 as a placeholder for release commits
+  { field = "id", pattern = "0000000", skip = true },
   { message = "^feat", group = "<!-- 00 -->Features" },
   { message = "^[fF]ix", group = "<!-- 01 -->Bug Fixes" },
   { message = "^refactor", group = "<!-- 02 -->Refactor" },
@@ -113,19 +139,23 @@ commit_parsers = [
   { message = "^style", group = "<!-- 05 -->Styling" },
   { message = "^test", group = "<!-- 06 -->Testing" },
   { message = "^chore\\(release\\): prepare for", skip = true },
+  { message = "^chore: release", skip = true },
   { message = "^chore\\(pr\\)", skip = true },
   { message = "^chore\\(pull\\)", skip = true },
   { message = "^chore\\(deps\\)", skip = true },
   { message = "^chore\\(changelog\\)", skip = true },
   { message = "^[cC]hore", group = "<!-- 07 -->Miscellaneous Tasks" },
-  { body = ".*security", group = "<!-- 08 -->Security" },
-  { message = "^build", group = "<!-- 09 -->Build" },
+  { message = "^build\\(deps\\)", skip = true },
+  { message = "^build\\(release\\)", skip = true },
+  { message = "^build", group = "<!-- 08 -->Build" },
+  { body = ".*security", group = "<!-- 09 -->Security" },
   { message = "^ci", group = "<!-- 10 -->Continuous Integration" },
   { message = "^revert", group = "<!-- 11 -->Reverted Commits" },
   # handle some old commits styles from pre 0.4
   { message = "^(Buffer|buffer|Frame|frame|Gauge|gauge|Paragraph|paragraph):", group = "<!-- 07 -->Miscellaneous Tasks" },
   { message = "^\\[", group = "<!-- 07 -->Miscellaneous Tasks" },
 ]
+
 # protect breaking changes from being skipped due to matching a skipping commit_parser
 protect_breaking_commits = false
 # filter out the commits that are not matched by commit parsers
@@ -133,9 +163,9 @@ filter_commits = false
 # glob pattern for matching git tags
 tag_pattern = "v[0-9]*"
 # regex for skipping tags
-skip_tags = "v0.1.0-rc.1"
+skip_tags = "beta|alpha|v0.1.0-rc.1"
 # regex for ignoring tags
-ignore_tags = "alpha"
+ignore_tags = "rc"
 # sort the tags topologically
 topo_order = false
 # sort the commits inside sections by oldest/newest order

clippy.toml

@@ -1,15 +1 @@
-# https://rust-lang.github.io/rust-clippy/master/index.html#/multiple_crate_versions
-# ratatui -> bitflags v2.3
-# termwiz -> wezterm-blob-leases -> mac_address -> nix -> bitflags v1.3.2
-# crossterm -> all the windows- deps https://github.com/ratatui-org/ratatui/pull/1064#issuecomment-2078848980
-allowed-duplicate-crates = [
-    "bitflags",
-    "windows-targets",
-    "windows_aarch64_gnullvm",
-    "windows_aarch64_msvc",
-    "windows_i686_gnu",
-    "windows_i686_msvc",
-    "windows_x86_64_gnu",
-    "windows_x86_64_gnullvm",
-    "windows_x86_64_msvc",
-]
+avoid-breaking-exported-api = false

deny.toml

@@ -1,23 +1,22 @@
 # configuration for https://github.com/EmbarkStudios/cargo-deny
 
 [licenses]
-default = "deny"
-unlicensed = "deny"
-copyleft = "deny"
+version = 2
 confidence-threshold = 0.8
 allow = [
-    "Apache-2.0",
-    "BSD-2-Clause",
-    "BSD-3-Clause",
-    "ISC",
-    "MIT",
-    "Unicode-DFS-2016",
-    "WTFPL",
+  "Apache-2.0",
+  "BSD-2-Clause",
+  "BSD-3-Clause",
+  "ISC",
+  "MIT",
+  "Unicode-3.0",
+  "Unicode-DFS-2016",
+  "WTFPL",
+  "Zlib",
 ]
 
 [advisories]
-unmaintained = "deny"
-yanked = "deny"
+version = 2
 
 [bans]
 multiple-versions = "allow"
@@ -26,3 +25,15 @@ multiple-versions = "allow"
 unknown-registry = "deny"
 unknown-git = "warn"
 allow-registry = ["https://github.com/rust-lang/crates.io-index"]
+
+[[licenses.clarify]]
+crate = "ring"
+# SPDX considers OpenSSL to encompass both the OpenSSL and SSLeay licenses
+# https://spdx.org/licenses/OpenSSL.html
+# ISC - Both BoringSSL and ring use this for their new files
+# MIT - "Files in third_party/ have their own licenses, as described therein. The MIT
+# license, for third_party/fiat, which, unlike other third_party directories, is
+# compiled into non-test libraries, is included below."
+# OpenSSL - Obviously
+expression = "ISC AND MIT AND OpenSSL"
+license-files = [{ path = "LICENSE", hash = 0xbd0eed23 }]

examples/README.md

@@ -1,6 +1,21 @@
 # Examples
 
-This folder might use unreleased code. View the examples for the latest release instead.
+This folder contains examples that are more application focused.
+
+> [!TIP]
+> There are also [widget examples] in `ratatui-widgets`.
+
+[widget examples]: ../ratatui-widgets/examples
+
+You can run these examples using:
+
+```shell
+cargo run -p example-name
+```
+
+> [!NOTE]
+> This folder might use unreleased code. Consider viewing the examples in the `latest` branch instead
+> of the `main` branch for code which is guaranteed to work with the released Ratatui version.
 
 > [!WARNING]
 >
@@ -10,317 +25,214 @@ This folder might use unreleased code. View the examples for the latest release
 > There are a few workaround for this problem:
 >
 > - View the examples as they were when the latest version was release by selecting the tag that
->   matches that version. E.g. <https://github.com/ratatui-org/ratatui/tree/v0.26.1/examples>.
-> - If you're viewing this file on GitHub, there is a combo box at the top of this page  which
+>   matches that version. E.g. <https://github.com/ratatui/ratatui/tree/v0.26.1/examples>.
+> - If you're viewing this file on GitHub, there is a combo box at the top of this page which
 >   allows you to select any previous tagged version.
 > - To view the code locally, checkout the tag. E.g. `git switch --detach v0.26.1`.
 > - Use the latest [alpha version of Ratatui] in your app. These are released weekly on Saturdays.
 > - Compile your code against the main branch either locally by adding e.g. `path = "../ratatui"` to
->   the dependency, or remotely by adding `git = "https://github.com/ratatui-org/ratatui"`
+>   the dependency, or remotely by adding `git = "https://github.com/ratatui/ratatui"`
 >
 > For a list of unreleased breaking changes, see [BREAKING-CHANGES.md].
 >
 > We don't keep the CHANGELOG updated with unreleased changes, check the git commit history or run
 > `git-cliff -u` against a cloned version of this repository.
 
-## Demo2
+## Design choices
 
-This is the demo example from the main README and crate page. Source: [demo2](./demo2/).
+The examples contain some opinionated choices in order to make it easier for newer rustaceans to
+easily be productive in creating applications:
 
-```shell
-cargo run --example=demo2 --features="crossterm widget-calendar"
-```
+- Each example has an `App` struct, with methods that implement a main loop, handle events and drawing
+  the UI.
+- We use `color_eyre` for handling errors and panics. See [How to use color-eyre with Ratatui] on the
+  website for more information about this.
+- Common code is not extracted into a separate file. This makes each example self-contained and easy
+  to read as a whole.
 
-![Demo2][demo2.gif]
+[How to use color-eyre with Ratatui]: https://ratatui.rs/recipes/apps/color-eyre/
 
 ## Demo
 
-This is the previous demo example from the main README. It is available for each of the backends. Source:
-[demo.rs](./demo/).
+This is the original demo example from the main README. It is available for each of the backends.
+[Source](./apps/demo/).
 
-```shell
-cargo run --example=demo --features=crossterm
-cargo run --example=demo --no-default-features --features=termion
-cargo run --example=demo --no-default-features --features=termwiz
-```
+![Demo](demo.gif)
 
-![Demo][demo.gif]
+## Demo2
 
-## Hello World
+This is the demo example from the main README and crate page. [Source](./apps/demo2/).
 
-This is a pretty boring example, but it contains some good documentation
-on writing tui apps. Source: [hello_world.rs](./hello_world.rs).
+![Demo2](demo2.gif)
 
-```shell
-cargo run --example=hello_world --features=crossterm
-```
+## Async GitHub
 
-![Hello World][hello_world.gif]
+Shows how to fetch data from GitHub API asynchronously. [Source](./apps/async-github/).
 
-## Barchart
+![Async GitHub demo][async-github.gif]
 
-Demonstrates the [`BarChart`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.BarChart.html)
-widget. Source: [barchart.rs](./barchart.rs).
+## Calendar Explorer
 
-```shell
-cargo run --example=barchart --features=crossterm
-```
+Shows how to render a calendar with different styles. [Source](./apps/calendar-explorer/).
 
-![Barchart][barchart.gif]
-
-## Block
-
-Demonstrates the [`Block`](https://docs.rs/ratatui/latest/ratatui/widgets/block/struct.Block.html)
-widget. Source: [block.rs](./block.rs).
-
-```shell
-cargo run --example=block --features=crossterm
-```
-
-![Block][block.gif]
-
-## Calendar
-
-Demonstrates the [`Calendar`](https://docs.rs/ratatui/latest/ratatui/widgets/calendar/index.html)
-widget. Source: [calendar.rs](./calendar.rs).
-
-```shell
-cargo run --example=calendar --features="crossterm widget-calendar"
-```
-
-![Calendar][calendar.gif]
+![Calendar explorer demo][calendar-explorer.gif]
 
 ## Canvas
 
-Demonstrates the [`Canvas`](https://docs.rs/ratatui/latest/ratatui/widgets/canvas/index.html) widget
-and related shapes in the
-[`canvas`](https://docs.rs/ratatui/latest/ratatui/widgets/canvas/index.html) module. Source:
-[canvas.rs](./canvas.rs).
+Shows how to render a canvas with different shapes. [Source](./apps/canvas/).
 
-```shell
-cargo run --example=canvas --features=crossterm
-```
-
-![Canvas][canvas.gif]
+![Canvas demo][canvas.gif]
 
 ## Chart
 
-Demonstrates the [`Chart`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Chart.html) widget.
-Source: [chart.rs](./chart.rs).
+Shows how to render line, bar, and scatter charts. [Source](./apps/chart/).
 
-```shell
-cargo run --example=chart --features=crossterm
-```
+![Chart demo][chart.gif]
 
-![Chart][chart.gif]
+## Color Explorer
 
-## Colors
+Shows how to handle the supported colors. [Source](./apps/color-explorer/).
 
-Demonstrates the available [`Color`](https://docs.rs/ratatui/latest/ratatui/style/enum.Color.html)
-options. These can be used in any style field. Source: [colors.rs](./colors.rs).
+![Color explorer demo][color-explorer.gif]
 
-```shell
-cargo run --example=colors --features=crossterm
-```
+## Colors-RGB demo
 
-![Colors][colors.gif]
+Shows the full range of RGB colors in an animation. [Source](./apps/colors-rgb/).
 
-## Colors (RGB)
+![Colors-RGB demo][colors-rgb.gif]
 
-Demonstrates the available RGB
-[`Color`](https://docs.rs/ratatui/latest/ratatui/style/enum.Color.html) options. These can be used
-in any style field. Source: [colors_rgb.rs](./colors_rgb.rs). Uses a half block technique to render
-two square-ish pixels in the space of a single rectangular terminal cell.
+## Constraint Explorer
 
-```shell
-cargo run --example=colors_rgb --features=crossterm
-```
+Shows how different constraints can be used to layout widgets. [Source](./apps/constraint-explorer/).
 
-Note: VHs renders full screen animations poorly, so this is a screen capture rather than the output
-of the VHS tape.
+![Constraint Explorer demo][constraint-explorer.gif]
 
-<https://github.com/ratatui-org/ratatui/assets/381361/485e775a-e0b5-4133-899b-1e8aeb56e774>
+## Constraints
+
+Shows different types of constraints. [Source](./apps/constraints/).
+
+![Constraints demo][constraints.gif]
 
 ## Custom Widget
 
-Demonstrates how to implement the
-[`Widget`](https://docs.rs/ratatui/latest/ratatui/widgets/trait.Widget.html) trait. Also shows mouse
-interaction. Source: [custom_widget.rs](./custom_widget.rs).
+Shows how to create a custom widget that can be interacted with the mouse. [Source](./apps/custom-widget/).
 
-```shell
-cargo run --example=custom_widget --features=crossterm
-```
+![Custom widget demo][custom-widget.gif]
 
-![Custom Widget][custom_widget.gif]
+## Hyperlink
+
+Shows how to render hyperlinks in a terminal using [OSC
+8](https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda). [Source](./apps/hyperlink/).
+
+![Hyperlink demo][hyperlink.gif]
+
+## Flex
+
+Shows how to use the flex layouts. [Source](./apps/flex/).
+
+![Flex demo][flex.gif]
+
+## Hello World
+
+Shows how to create a simple TUI with a text. [Source](./apps/hello-world/).
+
+![Hello World demo][hello-world.gif]
 
 ## Gauge
 
-Demonstrates the [`Gauge`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Gauge.html) widget.
-Source: [gauge.rs](./gauge.rs).
-
-```shell
-cargo run --example=gauge --features=crossterm
-```
-
-![Gauge][gauge.gif]
+Shows different types of gauges. [Source](./apps/gauge/).
 
 ## Inline
 
-Demonstrates how to use the
-[`Inline`](https://docs.rs/ratatui/latest/ratatui/terminal/enum.Viewport.html#variant.Inline)
-Viewport mode for ratatui apps. Source: [inline.rs](./inline.rs).
+Shows how to use the inlined viewport to render in a specific area of the screen. [Source](./apps/inline/).
 
-```shell
-cargo run --example=inline --features=crossterm
-```
+![Inline demo][inline.gif]
 
-![Inline][inline.gif]
+## Input Form
 
-## Layout
-
-Demonstrates the [`Layout`](https://docs.rs/ratatui/latest/ratatui/layout/struct.Layout.html) and
-interaction between each constraint. Source:  [layout.rs](./layout.rs).
-
-```shell
-cargo run --example=layout --features=crossterm
-```
-
-![Layout][layout.gif]
-
-## List
-
-Demonstrates the [`List`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.List.html) widget.
-Source: [list.rs](./list.rs).
-
-```shell
-cargo run --example=list --features=crossterm
-```
-
-![List][list.gif]
+Shows how to render a form with input fields. [Source](./apps/input-form/).
 
 ## Modifiers
 
-Demonstrates the style
-[`Modifiers`](https://docs.rs/ratatui/latest/ratatui/style/struct.Modifier.html). Source:
-[modifiers.rs](./modifiers.rs).
+Shows different types of modifiers. [Source](./apps/modifiers/).
 
-```shell
-cargo run --example=modifiers --features=crossterm
-```
+![Modifiers demo][modifiers.gif]
 
-![Modifiers][modifiers.gif]
+## Mouse Drawing
+
+Shows how to handle mouse events. [Source](./apps/mouse-drawing/).
+
+## Minimal
+
+Shows how to create a minimal application. [Source](./apps/minimal/).
+
+![Minimal demo][minimal.gif]
 
 ## Panic
 
-Demonstrates how to handle panics by ensuring that panic messages are written correctly to the
-screen. Source: [panic.rs](./panic.rs).
+Shows how to handle panics. [Source](./apps/panic/).
 
-```shell
-cargo run --example=panic --features=crossterm
-```
-
-![Panic][panic.gif]
-
-## Paragraph
-
-Demonstrates the [`Paragraph`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Paragraph.html)
-widget. Source: [paragraph.rs](./paragraph.rs)
-
-```shell
-cargo run --example=paragraph --features=crossterm
-```
-
-![Paragraph][paragraph.gif]
+![Panic demo][panic.gif]
 
 ## Popup
 
-Demonstrates how to render a widget over the top of previously rendered widgets using the
-[`Clear`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Clear.html) widget. Source:
-[popup.rs](./popup.rs).
+Shows how to handle popups. [Source](./apps/popup/).
 
->
-```shell
-cargo run --example=popup --features=crossterm
-```
-
-![Popup][popup.gif]
-
-## Ratatui-logo
-
-A fun example of using half blocks to render graphics Source:
-[ratatui-logo.rs](./ratatui-logo.rs).
-
->
-```shell
-cargo run --example=ratatui-logo --features=crossterm
-```
-
-![Ratatui Logo][ratatui-logo.gif]
+![Popup demo][popup.gif]
 
 ## Scrollbar
 
-Demonstrates the [`Scrollbar`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Scrollbar.html)
-widget. Source: [scrollbar.rs](./scrollbar.rs).
+Shows how to render different types of scrollbars. [Source](./apps/scrollbar/).
 
-```shell
-cargo run --example=scrollbar --features=crossterm
-```
-
-![Scrollbar][scrollbar.gif]
-
-## Sparkline
-
-Demonstrates the [`Sparkline`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Sparkline.html)
-widget. Source: [sparkline.rs](./sparkline.rs).
-
-```shell
-cargo run --example=sparkline --features=crossterm
-```
-
-![Sparkline][sparkline.gif]
+![Scrollbar demo][scrollbar.gif]
 
 ## Table
 
-Demonstrates the [`Table`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Table.html) widget.
-Source: [table.rs](./table.rs).
+Shows how to create an interactive table. [Source](./apps/table/).
 
-```shell
-cargo run --example=table --features=crossterm
-```
+![Table demo][table.gif]
 
-![Table][table.gif]
+## Todo List
 
-## Tabs
+Shows how to create a simple todo list application. [Source](./apps/todo-list/).
 
-Demonstrates the [`Tabs`](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Tabs.html) widget.
-Source: [tabs.rs](./tabs.rs).
+![Todo List demo][todo-list.gif]
 
-```shell
-cargo run --example=tabs --features=crossterm
-```
+## Tracing
 
-![Tabs][tabs.gif]
+Shows how to use the [tracing](https://crates.io/crates/tracing) crate to log to a file. [Source](./apps/tracing/).
+
+![Tracing demo][tracing.gif]
 
 ## User Input
 
-Demonstrates one approach to accepting user input. Source [user_input.rs](./user_input.rs).
+Shows how to handle user input. [Source](./apps/user-input/).
 
-> [!NOTE]
-> Consider using [`tui-textarea`](https://crates.io/crates/tui-textarea) or
-> [`tui-input`](https://crates.io/crates/tui-input) crates for more functional text entry UIs.
+![User input demo][user-input.gif]
 
-```shell
-cargo run --example=user_input --features=crossterm
-```
+## Weather
 
-![User Input][user_input.gif]
+Shows how to render weather data using barchart widget. [Source](./apps/weather/).
 
-## How to update these examples
+## WidgetRef Container
+
+Shows how to use [`WidgetRef`](https://docs.rs/ratatui/latest/ratatui/widgets/trait.WidgetRef.html) to store widgets in a container. [Source](./apps/widget-ref-container/).
+
+## Advanced Widget Implementation
+
+Shows how to render the `Widget` trait in different ways.
+
+![Advanced widget impl demo][advanced-widget-impl.gif]
+
+---
+
+<details>
+  <summary>How to update these examples?</summary>
 
 These gifs were created using [VHS](https://github.com/charmbracelet/vhs). Each example has a
 corresponding `.tape` file that holds instructions for how to generate the images. Note that the
-images themselves are stored in a separate `images` git branch to avoid bloating the main
-repository.
+images themselves are stored in a separate `images` git branch to avoid bloating the `main`
+branch.
 
 <!--
 
@@ -328,34 +240,36 @@ Links to images to make them easier to update in bulk. Use the following script
 the examples to the images branch. (Requires push access to the branch).
 
 ```shell
-examples/vhs/generate.bash
+vhs/generate.bash
 ```
 -->
 
-[barchart.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/barchart.gif?raw=true
-[block.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/block.gif?raw=true
-[calendar.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/calendar.gif?raw=true
-[canvas.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/canvas.gif?raw=true
-[chart.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/chart.gif?raw=true
-[colors.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/colors.gif?raw=true
-[custom_widget.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/custom_widget.gif?raw=true
-[demo.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/demo.gif?raw=true
-[demo2.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/demo2.gif?raw=true
-[gauge.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/gauge.gif?raw=true
-[hello_world.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/hello_world.gif?raw=true
-[inline.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/inline.gif?raw=true
-[layout.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/layout.gif?raw=true
-[list.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/list.gif?raw=true
-[modifiers.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/modifiers.gif?raw=true
-[panic.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/panic.gif?raw=true
-[paragraph.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/paragraph.gif?raw=true
-[popup.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/popup.gif?raw=true
-[ratatui-logo.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/ratatui-logo.gif?raw=true
-[scrollbar.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/scrollbar.gif?raw=true
-[sparkline.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/sparkline.gif?raw=true
-[table.gif]:  https://vhs.charm.sh/vhs-6njXBytDf0rwPufUtmSSpI.gif
-[tabs.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/tabs.gif?raw=true
-[user_input.gif]: https://github.com/ratatui-org/ratatui/blob/images/examples/user_input.gif?raw=true
+</details>
 
-[alpha version of Ratatui]: https://crates.io/crates/ratatui/versions
-[BREAKING-CHANGES.md]: https://github.com/ratatui-org/ratatui/blob/main/BREAKING-CHANGES.md
+[advanced-widget-impl.gif]: https://github.com/ratatui/ratatui/blob/images/examples/advanced-widget-impl.gif?raw=true
+[async-github.gif]: https://github.com/ratatui/ratatui/blob/images/examples/async-github.gif?raw=true
+[calendar-explorer.gif]: https://github.com/ratatui/ratatui/blob/images/examples/calendar-explorer.gif?raw=true
+[canvas.gif]: https://github.com/ratatui/ratatui/blob/images/examples/canvas.gif?raw=true
+[chart.gif]: https://github.com/ratatui/ratatui/blob/images/examples/chart.gif?raw=true
+[color-explorer.gif]: https://github.com/ratatui/ratatui/blob/images/examples/color-explorer.gif?raw=true
+[colors-rgb.gif]: https://github.com/ratatui/ratatui/blob/images/examples/colors-rgb.gif?raw=true
+[constraint-explorer.gif]: https://github.com/ratatui/ratatui/blob/images/examples/constraint-explorer.gif?raw=true
+[constraints.gif]: https://github.com/ratatui/ratatui/blob/images/examples/constraints.gif?raw=true
+[custom-widget.gif]: https://github.com/ratatui/ratatui/blob/images/examples/custom-widget.gif?raw=true
+[demo2-destroy.gif]: https://github.com/ratatui/ratatui/blob/images/examples/demo2-destroy.gif?raw=true
+[demo2-social.gif]: https://github.com/ratatui/ratatui/blob/images/examples/demo2-social.gif?raw=true
+[demo2.gif]: https://github.com/ratatui/ratatui/blob/images/examples/demo2.gif?raw=true
+[demo.gif]: https://github.com/ratatui/ratatui/blob/images/examples/demo.gif?raw=true
+[flex.gif]: https://github.com/ratatui/ratatui/blob/images/examples/flex.gif?raw=true
+[hello-world.gif]: https://github.com/ratatui/ratatui/blob/images/examples/hello-world.gif?raw=true
+[hyperlink.gif]: https://github.com/ratatui/ratatui/blob/images/examples/hyperlink.gif?raw=true
+[inline.gif]: https://github.com/ratatui/ratatui/blob/images/examples/inline.gif?raw=true
+[minimal.gif]: https://github.com/ratatui/ratatui/blob/images/examples/minimal.gif?raw=true
+[modifiers.gif]: https://github.com/ratatui/ratatui/blob/images/examples/modifiers.gif?raw=true
+[panic.gif]: https://github.com/ratatui/ratatui/blob/images/examples/panic.gif?raw=true
+[popup.gif]: https://github.com/ratatui/ratatui/blob/images/examples/popup.gif?raw=true
+[scrollbar.gif]: https://github.com/ratatui/ratatui/blob/images/examples/scrollbar.gif?raw=true
+[table.gif]: https://github.com/ratatui/ratatui/blob/images/examples/table.gif?raw=true
+[todo-list.gif]: https://github.com/ratatui/ratatui/blob/images/examples/todo-list.gif?raw=true
+[tracing.gif]: https://github.com/ratatui/ratatui/blob/images/examples/tracing.gif?raw=true
+[user-input.gif]: https://github.com/ratatui/ratatui/blob/images/examples/user-input.gif?raw=true

examples/apps/advanced-widget-impl/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "advanced-widget-impl"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm.workspace = true
+ratatui = { workspace = true, features = ["unstable-widget-ref"] }
+
+[lints]
+workspace = true

examples/apps/advanced-widget-impl/README.md

@@ -0,0 +1,9 @@
+# Advanced Widget Implementation demo
+
+This example shows how to render the `Widget` trait in different ways.
+
+To run this demo:
+
+```shell
+cargo run -p advanced-widget-impl
+```

examples/apps/advanced-widget-impl/src/main.rs

@@ -0,0 +1,241 @@
+/// A Ratatui example that demonstrates how to implement the `Widget` trait.
+///
+/// This example demonstrates various ways to implement `Widget` traits in Ratatui on a type, a
+/// reference, and a mutable reference. It also shows how to use the `WidgetRef` trait to
+/// render boxed widgets.
+///
+/// This example runs with the Ratatui library code in the branch that you are currently
+/// reading. See the [`latest`] branch for the code which works with the most recent Ratatui
+/// release.
+///
+/// [`latest`]: https://github.com/ratatui/ratatui/tree/latest
+use std::time::{Duration, Instant};
+
+use color_eyre::Result;
+use crossterm::event;
+use ratatui::DefaultTerminal;
+use ratatui::buffer::Buffer;
+use ratatui::layout::{Constraint, Layout, Position, Rect, Size};
+use ratatui::style::{Color, Style};
+use ratatui::widgets::{Widget, WidgetRef};
+
+fn main() -> Result<()> {
+    color_eyre::install()?;
+    ratatui::run(|terminal| App::default().run(terminal))
+}
+
+#[derive(Default)]
+struct App {
+    should_quit: bool,
+    timer: Timer,
+    boxed_squares: BoxedSquares,
+    green_square: RightAlignedSquare,
+}
+
+impl App {
+    fn run(mut self, terminal: &mut DefaultTerminal) -> Result<()> {
+        while !self.should_quit {
+            self.render(terminal)?;
+            self.handle_events()?;
+        }
+        Ok(())
+    }
+
+    fn render(&mut self, tui: &mut DefaultTerminal) -> Result<()> {
+        tui.draw(|frame| frame.render_widget(self, frame.area()))?;
+        Ok(())
+    }
+
+    fn handle_events(&mut self) -> Result<()> {
+        // Handle events at least 50 frames per second (gifs are usually 50fps)
+        let timeout = Duration::from_secs_f64(1.0 / 50.0);
+        if !event::poll(timeout)? {
+            return Ok(());
+        }
+        if event::read()?.is_key_press() {
+            self.should_quit = true;
+        }
+        Ok(())
+    }
+}
+
+/// Implement the `Widget` trait on a mutable reference to the `App` type.
+///
+/// This allows the `App` type to be rendered as a widget. The `App` type owns several other widgets
+/// that are rendered as part of the app. The `Widget` trait is implemented on a mutable reference
+/// to the `App` type, which allows this to be rendered without consuming the `App` type, and allows
+/// the sub-widgets to be mutable.
+impl Widget for &mut App {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        let constraints = Constraint::from_lengths([1, 1, 2, 1]);
+        let [greeting, timer, squares, position] = area.layout(&Layout::vertical(constraints));
+
+        // render an ephemeral greeting widget
+        Greeting::new("Ratatui!").render(greeting, buf);
+
+        // render a reference to the timer widget
+        self.timer.render(timer, buf);
+
+        // render a boxed widget containing red and blue squares
+        self.boxed_squares.render(squares, buf);
+
+        // render a mutable reference to the green square widget
+        self.green_square.render(squares, buf);
+        // Display the dynamically updated position of the green square
+        let square_position = format!("Green square is at {}", self.green_square.last_position);
+        square_position.render(position, buf);
+    }
+}
+
+/// An ephemeral greeting widget.
+///
+/// This widget is implemented on the type itself, which means that it is consumed when it is
+/// rendered. This is useful for widgets that are cheap to create, don't need to be reused, and
+/// don't need to store any state between renders. This is the simplest way to implement a widget in
+/// Ratatui, but in most cases, it is better to implement the `Widget` trait on a reference to the
+/// type, as shown in the other examples below.
+///
+/// This was the way most widgets were implemented in Ratatui before `Widget` was implemented on
+/// references in [PR #903] (merged in Ratatui 0.26.0).
+///
+/// [PR #903]: https://github.com/ratatui/ratatui/pull/903
+struct Greeting {
+    name: String,
+}
+
+impl Greeting {
+    fn new(name: &str) -> Self {
+        Self {
+            name: name.to_string(),
+        }
+    }
+}
+
+impl Widget for Greeting {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        let greeting = format!("Hello, {}!", self.name);
+        greeting.render(area, buf);
+    }
+}
+
+/// A timer widget that displays the elapsed time since the timer was started.
+#[derive(Debug)]
+struct Timer {
+    start: Instant,
+}
+
+impl Default for Timer {
+    fn default() -> Self {
+        Self {
+            start: Instant::now(),
+        }
+    }
+}
+
+/// This implements `Widget` on a reference to the type, which means that it can be reused and
+/// doesn't need to be consumed when it is rendered. This is useful for widgets that need to store
+/// state and be updated over time.
+///
+/// This approach was probably always available in Ratatui, but it wasn't widely used until `Widget`
+/// was implemented on references in [PR #903] (merged in Ratatui 0.26.0). This is because all the
+/// built-in widgets previously would consume themselves when rendered.
+impl Widget for &Timer {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        let elapsed = self.start.elapsed().as_secs_f32();
+        let message = format!("Elapsed: {elapsed:.1?}s");
+        message.render(area, buf);
+    }
+}
+
+/// A widget that contains a list of several different widgets.
+struct BoxedSquares {
+    squares: Vec<Box<dyn WidgetRef>>,
+}
+
+impl Default for BoxedSquares {
+    fn default() -> Self {
+        let red_square: Box<dyn WidgetRef> = Box::new(RedSquare);
+        let blue_square: Box<dyn WidgetRef> = Box::new(BlueSquare);
+        Self {
+            squares: vec![red_square, blue_square],
+        }
+    }
+}
+
+/// A widget that renders a red square.
+struct RedSquare;
+
+/// A widget that renders a blue square.
+struct BlueSquare;
+
+/// This implements the `Widget` trait on a reference to the type. It contains a list of boxed
+/// widgets that implement the `WidgetRef` trait. This is useful for widgets that contain a list of
+/// other widgets that can be different types.
+impl Widget for &BoxedSquares {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        let constraints = vec![Constraint::Length(4); self.squares.len()];
+        let areas = area.layout_vec(&Layout::horizontal(constraints));
+        for (widget, area) in self.squares.iter().zip(areas) {
+            widget.render_ref(area, buf);
+        }
+    }
+}
+
+/// `RedSquare` and `BlueSquare` are widgets that render a red and blue square, respectively. They
+/// implement the `WidgetRef` trait instead of the `Widget` trait, which which allows them to be
+/// rendered as boxed widgets. It's not possible to use Widget for this as a dynamic reference to a
+/// widget cannot generally be moved out of the box.
+impl WidgetRef for RedSquare {
+    fn render_ref(&self, area: Rect, buf: &mut Buffer) {
+        fill(area, buf, "█", Color::Red);
+    }
+}
+
+impl WidgetRef for BlueSquare {
+    fn render_ref(&self, area: Rect, buf: &mut Buffer) {
+        fill(area, buf, "█", Color::Blue);
+    }
+}
+
+/// A widget that renders a green square aligned to the right of the area.
+#[derive(Default)]
+struct RightAlignedSquare {
+    last_position: Position,
+}
+
+/// This widget is implemented on a mutable reference to the type, which means that it can store
+/// state and update it when it is rendered. This is useful for widgets that need to store the
+/// result of some calculation that can only be done when the widget is rendered.
+///
+/// The x and y coordinates of the square are stored in the widget and updated when the widget is
+/// rendered. This allows the square to be aligned to the right of the area. These coordinates could
+/// be used to perform hit testing (e.g. checking if a mouse click is inside the square). This app
+/// just displays the coordinates as a string.
+///
+/// This approach was probably always available in Ratatui, but it wasn't widely used either. This
+/// is an alternative to implementing the `StatefulWidget` trait, for situations where you want to
+/// store the state in the widget itself instead of a separate struct.
+impl Widget for &mut RightAlignedSquare {
+    /// Render a green square aligned to the right of the area and store the position.
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        const WIDTH: u16 = 4;
+        let x = area.right() - WIDTH; // Align to the right
+        self.last_position = Position { x, y: area.y };
+        let size = Size::new(WIDTH, area.height);
+        let area = Rect::from((self.last_position, size));
+        fill(area, buf, "█", Color::Green);
+    }
+}
+
+/// Fill the area with the specified symbol and style.
+///
+/// This probably should be a method on the `Buffer` type, but it is defined here for simplicity.
+/// <https://github.com/ratatui/ratatui/issues/1146>
+fn fill<S: Into<Style>>(area: Rect, buf: &mut Buffer, symbol: &str, style: S) {
+    let style = style.into();
+    for y in area.top()..area.bottom() {
+        for x in area.left()..area.right() {
+            buf[(x, y)].set_symbol(symbol).set_style(style);
+        }
+    }
+}

examples/apps/async-github/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "async-github"
+publish = false
+authors.workspace = true
+documentation.workspace = true
+repository.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+readme.workspace = true
+license.workspace = true
+exclude.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm = { workspace = true, features = ["event-stream"] }
+octocrab.workspace = true
+ratatui.workspace = true
+tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
+tokio-stream.workspace = true

examples/apps/async-github/README.md

@@ -0,0 +1,9 @@
+# Async GitHub demo
+
+This example demonstrates how to use Ratatui with widgets that fetch data from GitHub API asynchronously.
+
+To run this demo:
+
+```shell
+cargo run -p async-github
+```

examples/apps/async-github/src/main.rs

@@ -0,0 +1,236 @@
+//! # [Ratatui] Async example
+//!
+//! This example demonstrates how to use Ratatui with widgets that fetch data asynchronously. It
+//! uses the `octocrab` crate to fetch a list of pull requests from the GitHub API.
+//!
+//! <https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens#creating-a-fine-grained-personal-access-token>
+//! <https://github.com/settings/tokens/new> to create a new token (select classic, and no scopes)
+//!
+//! This example does not cover message passing between threads, it only demonstrates how to manage
+//! shared state between the main thread and a background task, which acts mostly as a one-shot
+//! fetcher. For more complex scenarios, you may need to use channels or other synchronization
+//! primitives.
+//!
+//! A simple app might have multiple widgets that fetch data from different sources, and each widget
+//! would have its own background task to fetch the data. The main thread would then render the
+//! widgets with the latest data.
+//!
+//! The latest version of this example is available in the [examples] folder in the repository.
+//!
+//! Please note that the examples are designed to be run against the `main` branch of the Github
+//! repository. This means that you may not be able to compile with the latest release version on
+//! crates.io, or the one that you have installed locally.
+//!
+//! See the [examples readme] for more information on finding examples that match the version of the
+//! library you are using.
+//!
+//! [Ratatui]: https://github.com/ratatui/ratatui
+//! [examples]: https://github.com/ratatui/ratatui/blob/main/examples
+//! [examples readme]: https://github.com/ratatui/ratatui/blob/main/examples/README.md
+use std::sync::{Arc, RwLock};
+use std::time::Duration;
+
+use color_eyre::Result;
+use crossterm::event::{Event, EventStream, KeyCode};
+use octocrab::Page;
+use octocrab::params::Direction;
+use octocrab::params::pulls::Sort;
+use ratatui::buffer::Buffer;
+use ratatui::layout::{Constraint, Layout, Rect};
+use ratatui::style::{Style, Stylize};
+use ratatui::text::Line;
+use ratatui::widgets::{Block, HighlightSpacing, Row, StatefulWidget, Table, TableState, Widget};
+use ratatui::{DefaultTerminal, Frame};
+use tokio_stream::StreamExt;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    color_eyre::install()?;
+    let terminal = ratatui::init();
+    let app_result = App::default().run(terminal).await;
+    ratatui::restore();
+    app_result
+}
+
+#[derive(Debug, Default)]
+struct App {
+    should_quit: bool,
+    pull_requests: PullRequestListWidget,
+}
+
+impl App {
+    const FRAMES_PER_SECOND: f32 = 60.0;
+
+    pub async fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
+        self.pull_requests.run();
+
+        let period = Duration::from_secs_f32(1.0 / Self::FRAMES_PER_SECOND);
+        let mut interval = tokio::time::interval(period);
+        let mut events = EventStream::new();
+
+        while !self.should_quit {
+            tokio::select! {
+                _ = interval.tick() => { terminal.draw(|frame| self.render(frame))?; },
+                Some(Ok(event)) = events.next() => self.handle_event(&event),
+            }
+        }
+        Ok(())
+    }
+
+    fn render(&self, frame: &mut Frame) {
+        let layout = Layout::vertical([Constraint::Length(1), Constraint::Fill(1)]);
+        let [title_area, body_area] = frame.area().layout(&layout);
+        let title = Line::from("Ratatui async example").centered().bold();
+        frame.render_widget(title, title_area);
+        frame.render_widget(&self.pull_requests, body_area);
+    }
+
+    fn handle_event(&mut self, event: &Event) {
+        if let Some(key) = event.as_key_press_event() {
+            match key.code {
+                KeyCode::Char('q') | KeyCode::Esc => self.should_quit = true,
+                KeyCode::Char('j') | KeyCode::Down => self.pull_requests.scroll_down(),
+                KeyCode::Char('k') | KeyCode::Up => self.pull_requests.scroll_up(),
+                _ => {}
+            }
+        }
+    }
+}
+
+/// A widget that displays a list of pull requests.
+///
+/// This is an async widget that fetches the list of pull requests from the GitHub API. It contains
+/// an inner `Arc<RwLock<PullRequestListState>>` that holds the state of the widget. Cloning the
+/// widget will clone the Arc, so you can pass it around to other threads, and this is used to spawn
+/// a background task to fetch the pull requests.
+#[derive(Debug, Clone, Default)]
+struct PullRequestListWidget {
+    state: Arc<RwLock<PullRequestListState>>,
+}
+
+#[derive(Debug, Default)]
+struct PullRequestListState {
+    pull_requests: Vec<PullRequest>,
+    loading_state: LoadingState,
+    table_state: TableState,
+}
+
+#[derive(Debug, Clone)]
+struct PullRequest {
+    id: String,
+    title: String,
+    url: String,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+enum LoadingState {
+    #[default]
+    Idle,
+    Loading,
+    Loaded,
+    Error(String),
+}
+
+impl PullRequestListWidget {
+    /// Start fetching the pull requests in the background.
+    ///
+    /// This method spawns a background task that fetches the pull requests from the GitHub API.
+    /// The result of the fetch is then passed to the `on_load` or `on_err` methods.
+    fn run(&self) {
+        let this = self.clone(); // clone the widget to pass to the background task
+        tokio::spawn(this.fetch_pulls());
+    }
+
+    async fn fetch_pulls(self) {
+        // this runs once, but you could also run this in a loop, using a channel that accepts
+        // messages to refresh on demand, or with an interval timer to refresh every N seconds
+        self.set_loading_state(LoadingState::Loading);
+        match octocrab::instance()
+            .pulls("ratatui", "ratatui")
+            .list()
+            .sort(Sort::Updated)
+            .direction(Direction::Descending)
+            .send()
+            .await
+        {
+            Ok(page) => self.on_load(&page),
+            Err(err) => self.on_err(&err),
+        }
+    }
+    fn on_load(&self, page: &Page<OctoPullRequest>) {
+        let prs = page.items.iter().map(Into::into);
+        let mut state = self.state.write().unwrap();
+        state.loading_state = LoadingState::Loaded;
+        state.pull_requests.extend(prs);
+        if !state.pull_requests.is_empty() {
+            state.table_state.select(Some(0));
+        }
+    }
+
+    fn on_err(&self, err: &octocrab::Error) {
+        self.set_loading_state(LoadingState::Error(err.to_string()));
+    }
+
+    fn set_loading_state(&self, state: LoadingState) {
+        self.state.write().unwrap().loading_state = state;
+    }
+
+    fn scroll_down(&self) {
+        self.state.write().unwrap().table_state.scroll_down_by(1);
+    }
+
+    fn scroll_up(&self) {
+        self.state.write().unwrap().table_state.scroll_up_by(1);
+    }
+}
+
+type OctoPullRequest = octocrab::models::pulls::PullRequest;
+
+impl From<&OctoPullRequest> for PullRequest {
+    fn from(pr: &OctoPullRequest) -> Self {
+        Self {
+            id: pr.number.to_string(),
+            title: pr.title.as_ref().unwrap().to_string(),
+            url: pr
+                .html_url
+                .as_ref()
+                .map(ToString::to_string)
+                .unwrap_or_default(),
+        }
+    }
+}
+
+impl Widget for &PullRequestListWidget {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        let mut state = self.state.write().unwrap();
+
+        // a block with a right aligned title with the loading state on the right
+        let loading_state = Line::from(format!("{:?}", state.loading_state)).right_aligned();
+        let block = Block::bordered()
+            .title("Pull Requests")
+            .title(loading_state)
+            .title_bottom("j/k to scroll, q to quit");
+
+        // a table with the list of pull requests
+        let rows = state.pull_requests.iter();
+        let widths = [
+            Constraint::Length(5),
+            Constraint::Fill(1),
+            Constraint::Max(49),
+        ];
+        let table = Table::new(rows, widths)
+            .block(block)
+            .highlight_spacing(HighlightSpacing::Always)
+            .highlight_symbol(">>")
+            .row_highlight_style(Style::new().on_blue());
+
+        StatefulWidget::render(table, area, buf, &mut state.table_state);
+    }
+}
+
+impl From<&PullRequest> for Row<'_> {
+    fn from(pr: &PullRequest) -> Self {
+        let pr = pr.clone();
+        Row::new(vec![pr.id, pr.title, pr.url])
+    }
+}

examples/apps/calendar-explorer/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "calendar-explorer"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm.workspace = true
+ratatui.workspace = true
+time = { workspace = true, features = ["formatting", "parsing"] }
+
+[lints]
+workspace = true

examples/apps/calendar-explorer/README.md

@@ -0,0 +1,9 @@
+# Calendar explorer demo
+
+This example shows how to render a calendar with different styles.
+
+To run this demo:
+
+```shell
+cargo run -p calendar-explorer
+```

examples/apps/calendar-explorer/src/main.rs

@@ -0,0 +1,236 @@
+//! A Ratatui example that demonstrates how to render calendar with different styles.
+//!
+//! Marks the holidays and seasons on the calendar.
+//!
+//! This example runs with the Ratatui library code in the branch that you are currently reading.
+//! See the [`latest`] branch for the code which works with the most recent Ratatui release.
+//!
+//! [`latest`]: https://github.com/ratatui/ratatui/tree/latest
+//! [`BarChart`]: https://docs.rs/ratatui/latest/ratatui/widgets/struct.BarChart.html
+
+use std::fmt;
+
+use color_eyre::Result;
+use crossterm::event::{self, KeyCode};
+use ratatui::layout::{Constraint, Layout, Margin, Rect};
+use ratatui::style::{Color, Modifier, Style, Stylize};
+use ratatui::text::{Line, Text};
+use ratatui::widgets::calendar::{CalendarEventStore, Monthly};
+use ratatui::{DefaultTerminal, Frame};
+use time::ext::NumericalDuration;
+use time::{Date, Month, OffsetDateTime};
+
+fn main() -> Result<()> {
+    color_eyre::install()?;
+    ratatui::run(run)
+}
+
+/// Run the application.
+fn run(terminal: &mut DefaultTerminal) -> Result<()> {
+    let mut selected_date = OffsetDateTime::now_local()?.date();
+    let mut calendar_style = StyledCalendar::Default;
+    loop {
+        terminal.draw(|frame| render(frame, calendar_style, selected_date))?;
+        if let Some(key) = event::read()?.as_key_press_event() {
+            match key.code {
+                KeyCode::Char('q') => break Ok(()),
+                KeyCode::Char('s') => calendar_style = calendar_style.next(),
+                KeyCode::Char('n') | KeyCode::Tab => selected_date = next_month(selected_date),
+                KeyCode::Char('p') | KeyCode::BackTab => selected_date = prev_month(selected_date),
+                KeyCode::Char('h') | KeyCode::Left => selected_date -= 1.days(),
+                KeyCode::Char('j') | KeyCode::Down => selected_date += 1.weeks(),
+                KeyCode::Char('k') | KeyCode::Up => selected_date -= 1.weeks(),
+                KeyCode::Char('l') | KeyCode::Right => selected_date += 1.days(),
+                _ => {}
+            }
+        }
+    }
+}
+
+fn next_month(date: Date) -> Date {
+    if date.month() == Month::December {
+        date.replace_month(Month::January)
+            .unwrap()
+            .replace_year(date.year() + 1)
+            .unwrap()
+    } else {
+        date.replace_month(date.month().next()).unwrap()
+    }
+}
+
+fn prev_month(date: Date) -> Date {
+    if date.month() == Month::January {
+        date.replace_month(Month::December)
+            .unwrap()
+            .replace_year(date.year() - 1)
+            .unwrap()
+    } else {
+        date.replace_month(date.month().previous()).unwrap()
+    }
+}
+
+/// Render the UI with a calendar.
+fn render(frame: &mut Frame, calendar_style: StyledCalendar, selected_date: Date) {
+    let header = Text::from_iter([
+        Line::from("Calendar Example".bold()),
+        Line::from(
+            "<q> Quit | <s> Change Style | <n> Next Month | <p> Previous Month, <hjkl> Move",
+        ),
+        Line::from(format!(
+            "Current date: {selected_date} | Current style: {calendar_style}"
+        )),
+    ]);
+
+    let [text_area, area] = frame.area().layout(&Layout::vertical([
+        Constraint::Length(header.height() as u16),
+        Constraint::Fill(1),
+    ]));
+    frame.render_widget(header.centered(), text_area);
+    calendar_style
+        .render_year(frame, area, selected_date)
+        .unwrap();
+}
+
+#[derive(Debug, Clone, Copy)]
+enum StyledCalendar {
+    Default,
+    Surrounding,
+    WeekdaysHeader,
+    SurroundingAndWeekdaysHeader,
+    MonthHeader,
+    MonthAndWeekdaysHeader,
+}
+
+impl StyledCalendar {
+    // Cycle through the different styles.
+    const fn next(self) -> Self {
+        match self {
+            Self::Default => Self::Surrounding,
+            Self::Surrounding => Self::WeekdaysHeader,
+            Self::WeekdaysHeader => Self::SurroundingAndWeekdaysHeader,
+            Self::SurroundingAndWeekdaysHeader => Self::MonthHeader,
+            Self::MonthHeader => Self::MonthAndWeekdaysHeader,
+            Self::MonthAndWeekdaysHeader => Self::Default,
+        }
+    }
+}
+
+impl fmt::Display for StyledCalendar {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Default => write!(f, "Default"),
+            Self::Surrounding => write!(f, "Show Surrounding"),
+            Self::WeekdaysHeader => write!(f, "Show Weekdays Header"),
+            Self::SurroundingAndWeekdaysHeader => write!(f, "Show Surrounding and Weekdays Header"),
+            Self::MonthHeader => write!(f, "Show Month Header"),
+            Self::MonthAndWeekdaysHeader => write!(f, "Show Month Header and Weekdays Header"),
+        }
+    }
+}
+
+impl StyledCalendar {
+    fn render_year(self, frame: &mut Frame, area: Rect, date: Date) -> Result<()> {
+        let events = events(date)?;
+
+        let vertical = Layout::vertical([Constraint::Ratio(1, 3); 3]);
+        let horizontal = &Layout::horizontal([Constraint::Ratio(1, 4); 4]);
+        let areas = area
+            .inner(Margin::new(1, 1))
+            .layout_vec(&vertical)
+            .into_iter()
+            .flat_map(|row| row.layout_vec(horizontal));
+        for (i, area) in areas.enumerate() {
+            let month = date
+                .replace_day(1)
+                .unwrap()
+                .replace_month(Month::try_from(i as u8 + 1).unwrap())
+                .unwrap();
+            self.render_month(frame, area, month, &events);
+        }
+        Ok(())
+    }
+
+    fn render_month(self, frame: &mut Frame, area: Rect, date: Date, events: &CalendarEventStore) {
+        let calendar = match self {
+            Self::Default => Monthly::new(date, events)
+                .default_style(Style::new().bold().bg(Color::Rgb(50, 50, 50)))
+                .show_month_header(Style::default()),
+            Self::Surrounding => Monthly::new(date, events)
+                .default_style(Style::new().bold().bg(Color::Rgb(50, 50, 50)))
+                .show_month_header(Style::default())
+                .show_surrounding(Style::new().dim()),
+            Self::WeekdaysHeader => Monthly::new(date, events)
+                .default_style(Style::new().bold().bg(Color::Rgb(50, 50, 50)))
+                .show_month_header(Style::default())
+                .show_weekdays_header(Style::new().bold().green()),
+            Self::SurroundingAndWeekdaysHeader => Monthly::new(date, events)
+                .default_style(Style::new().bold().bg(Color::Rgb(50, 50, 50)))
+                .show_month_header(Style::default())
+                .show_surrounding(Style::new().dim())
+                .show_weekdays_header(Style::new().bold().green()),
+            Self::MonthHeader => Monthly::new(date, events)
+                .default_style(Style::new().bold().bg(Color::Rgb(50, 50, 50)))
+                .show_month_header(Style::default())
+                .show_month_header(Style::new().bold().green()),
+            Self::MonthAndWeekdaysHeader => Monthly::new(date, events)
+                .default_style(Style::new().bold().bg(Color::Rgb(50, 50, 50)))
+                .show_month_header(Style::default())
+                .show_weekdays_header(Style::new().bold().dim().light_yellow()),
+        };
+        frame.render_widget(calendar, area);
+    }
+}
+
+/// Makes a list of dates for the current year.
+fn events(selected_date: Date) -> Result<CalendarEventStore> {
+    const SELECTED: Style = Style::new()
+        .fg(Color::White)
+        .bg(Color::Red)
+        .add_modifier(Modifier::BOLD);
+    const HOLIDAY: Style = Style::new()
+        .fg(Color::Red)
+        .add_modifier(Modifier::UNDERLINED);
+    const SEASON: Style = Style::new()
+        .fg(Color::Green)
+        .bg(Color::Black)
+        .add_modifier(Modifier::UNDERLINED);
+
+    let mut list = CalendarEventStore::today(
+        Style::default()
+            .add_modifier(Modifier::BOLD)
+            .bg(Color::Blue),
+    );
+    let y = selected_date.year();
+
+    // new year's
+    list.add(Date::from_calendar_date(y, Month::January, 1)?, HOLIDAY);
+    // next new_year's for December "show surrounding"
+    list.add(Date::from_calendar_date(y + 1, Month::January, 1)?, HOLIDAY);
+    // groundhog day
+    list.add(Date::from_calendar_date(y, Month::February, 2)?, HOLIDAY);
+    // april fool's
+    list.add(Date::from_calendar_date(y, Month::April, 1)?, HOLIDAY);
+    // earth day
+    list.add(Date::from_calendar_date(y, Month::April, 22)?, HOLIDAY);
+    // star wars day
+    list.add(Date::from_calendar_date(y, Month::May, 4)?, HOLIDAY);
+    // festivus
+    list.add(Date::from_calendar_date(y, Month::December, 23)?, HOLIDAY);
+    // new year's eve
+    list.add(Date::from_calendar_date(y, Month::December, 31)?, HOLIDAY);
+
+    // seasons
+    // spring equinox
+    list.add(Date::from_calendar_date(y, Month::March, 22)?, SEASON);
+    // summer solstice
+    list.add(Date::from_calendar_date(y, Month::June, 21)?, SEASON);
+    // fall equinox
+    list.add(Date::from_calendar_date(y, Month::September, 22)?, SEASON);
+    // winter solstice
+    list.add(Date::from_calendar_date(y, Month::December, 21)?, SEASON);
+
+    // selected date
+    list.add(selected_date, SELECTED);
+
+    Ok(list)
+}

examples/apps/canvas/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "canvas"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm.workspace = true
+itertools.workspace = true
+ratatui.workspace = true
+
+[lints]
+workspace = true

examples/apps/canvas/README.md

@@ -0,0 +1,9 @@
+# Canvas demo
+
+This example shows how to render various shapes and a map on a canvas.
+
+To run this demo:
+
+```shell
+cargo run -p canvas
+```

examples/apps/canvas/src/main.rs

@@ -0,0 +1,263 @@
+/// A Ratatui example that demonstrates how to draw on a canvas.
+///
+/// This example demonstrates how to draw various shapes such as rectangles, circles, and lines
+/// on a canvas. It also demonstrates how to draw a map.
+///
+/// This example runs with the Ratatui library code in the branch that you are currently
+/// reading. See the [`latest`] branch for the code which works with the most recent Ratatui
+/// release.
+///
+/// [`latest`]: https://github.com/ratatui/ratatui/tree/latest
+use std::{
+    io::stdout,
+    time::{Duration, Instant},
+};
+
+use color_eyre::Result;
+use crossterm::ExecutableCommand;
+use crossterm::event::{
+    self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEvent, MouseEventKind,
+};
+use itertools::Itertools;
+use ratatui::layout::{Constraint, Layout, Position, Rect};
+use ratatui::style::{Color, Stylize};
+use ratatui::symbols::Marker;
+use ratatui::text::Text;
+use ratatui::widgets::canvas::{Canvas, Circle, Map, MapResolution, Points, Rectangle};
+use ratatui::widgets::{Block, Widget};
+use ratatui::{DefaultTerminal, Frame};
+
+fn main() -> Result<()> {
+    color_eyre::install()?;
+    stdout().execute(EnableMouseCapture)?;
+    let terminal = ratatui::init();
+    let app_result = App::new().run(terminal);
+    ratatui::restore();
+    stdout().execute(DisableMouseCapture)?;
+    app_result
+}
+
+struct App {
+    exit: bool,
+    x: f64,
+    y: f64,
+    ball: Circle,
+    playground: Rect,
+    vx: f64,
+    vy: f64,
+    marker: Marker,
+    points: Vec<Position>,
+    is_drawing: bool,
+}
+
+impl App {
+    const fn new() -> Self {
+        Self {
+            exit: false,
+            x: 0.0,
+            y: 0.0,
+            ball: Circle {
+                x: 20.0,
+                y: 40.0,
+                radius: 10.0,
+                color: Color::Yellow,
+            },
+            playground: Rect::new(10, 10, 200, 100),
+            vx: 1.0,
+            vy: 1.0,
+            marker: Marker::Dot,
+            points: vec![],
+            is_drawing: false,
+        }
+    }
+
+    pub fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
+        let tick_rate = Duration::from_millis(16);
+        let mut last_tick = Instant::now();
+        while !self.exit {
+            terminal.draw(|frame| self.render(frame))?;
+            let timeout = tick_rate.saturating_sub(last_tick.elapsed());
+            if !event::poll(timeout)? {
+                self.on_tick();
+                last_tick = Instant::now();
+                continue;
+            }
+            match event::read()? {
+                Event::Key(key) => self.handle_key_event(key),
+                Event::Mouse(event) => self.handle_mouse_event(event),
+                _ => (),
+            }
+        }
+        Ok(())
+    }
+
+    fn handle_key_event(&mut self, key: KeyEvent) {
+        if !key.is_press() {
+            return;
+        }
+        match key.code {
+            KeyCode::Char('q') | KeyCode::Esc => self.exit = true,
+            KeyCode::Char('j') | KeyCode::Down => self.y += 1.0,
+            KeyCode::Char('k') | KeyCode::Up => self.y -= 1.0,
+            KeyCode::Char('l') | KeyCode::Right => self.x += 1.0,
+            KeyCode::Char('h') | KeyCode::Left => self.x -= 1.0,
+            KeyCode::Enter => self.cycle_marker(),
+            _ => {}
+        }
+    }
+
+    fn handle_mouse_event(&mut self, event: event::MouseEvent) {
+        match event.kind {
+            MouseEventKind::Down(_) => self.is_drawing = true,
+            MouseEventKind::Up(_) => self.is_drawing = false,
+            MouseEventKind::Drag(_) => {
+                self.points.push(Position::new(event.column, event.row));
+            }
+            _ => {}
+        }
+    }
+
+    const fn cycle_marker(&mut self) {
+        self.marker = match self.marker {
+            Marker::Dot => Marker::Braille,
+            Marker::Braille => Marker::Block,
+            Marker::Block => Marker::HalfBlock,
+            Marker::HalfBlock => Marker::Quadrant,
+            Marker::Quadrant => Marker::Sextant,
+            Marker::Sextant => Marker::Octant,
+            Marker::Octant => Marker::Bar,
+            Marker::Bar => Marker::Dot,
+            _ => unreachable!(),
+        };
+    }
+
+    fn on_tick(&mut self) {
+        // bounce the ball by flipping the velocity vector
+        let ball = &self.ball;
+        let playground = self.playground;
+        if ball.x - ball.radius < f64::from(playground.left())
+            || ball.x + ball.radius > f64::from(playground.right())
+        {
+            self.vx = -self.vx;
+        }
+        if ball.y - ball.radius < f64::from(playground.top())
+            || ball.y + ball.radius > f64::from(playground.bottom())
+        {
+            self.vy = -self.vy;
+        }
+        self.ball.x += self.vx;
+        self.ball.y += self.vy;
+    }
+
+    fn render(&self, frame: &mut Frame) {
+        let header = Text::from_iter([
+            "Canvas Example".bold(),
+            "<q> Quit | <enter> Change Marker | <hjkl> Move".into(),
+        ]);
+
+        let vertical = Layout::vertical([
+            Constraint::Length(header.height() as u16),
+            Constraint::Fill(1),
+            Constraint::Fill(1),
+        ]);
+        let [text_area, up, down] = frame.area().layout(&vertical);
+        frame.render_widget(header.centered(), text_area);
+
+        let horizontal = Layout::horizontal([Constraint::Fill(1); 2]);
+        let [draw, pong] = up.layout(&horizontal);
+        let [map, boxes] = down.layout(&horizontal);
+
+        frame.render_widget(self.map_canvas(), map);
+        frame.render_widget(self.draw_canvas(draw), draw);
+        frame.render_widget(self.pong_canvas(), pong);
+        frame.render_widget(self.boxes_canvas(boxes), boxes);
+    }
+
+    fn map_canvas(&self) -> impl Widget + '_ {
+        Canvas::default()
+            .block(Block::bordered().title("World"))
+            .marker(self.marker)
+            .paint(|ctx| {
+                ctx.draw(&Map {
+                    color: Color::Green,
+                    resolution: MapResolution::High,
+                });
+                ctx.print(self.x, -self.y, "You are here".yellow());
+            })
+            .x_bounds([-180.0, 180.0])
+            .y_bounds([-90.0, 90.0])
+    }
+
+    fn draw_canvas(&self, area: Rect) -> impl Widget + '_ {
+        Canvas::default()
+            .block(Block::bordered().title("Draw here"))
+            .marker(self.marker)
+            .x_bounds([0.0, f64::from(area.width)])
+            .y_bounds([0.0, f64::from(area.height)])
+            .paint(move |ctx| {
+                let points = self
+                    .points
+                    .iter()
+                    .map(|p| {
+                        (
+                            f64::from(p.x) - f64::from(area.left()),
+                            f64::from(area.bottom()) - f64::from(p.y),
+                        )
+                    })
+                    .collect_vec();
+                ctx.draw(&Points {
+                    coords: &points,
+                    color: Color::White,
+                });
+            })
+    }
+
+    fn pong_canvas(&self) -> impl Widget + '_ {
+        Canvas::default()
+            .block(Block::bordered().title("Pong"))
+            .marker(self.marker)
+            .paint(|ctx| {
+                ctx.draw(&self.ball);
+            })
+            .x_bounds([10.0, 210.0])
+            .y_bounds([10.0, 110.0])
+    }
+
+    fn boxes_canvas(&self, area: Rect) -> impl Widget {
+        let left = 0.0;
+        let right = f64::from(area.width);
+        let bottom = 0.0;
+        let top = f64::from(area.height).mul_add(2.0, -4.0);
+        Canvas::default()
+            .block(Block::bordered().title("Rects"))
+            .marker(self.marker)
+            .x_bounds([left, right])
+            .y_bounds([bottom, top])
+            .paint(|ctx| {
+                for i in 0..=11 {
+                    ctx.draw(&Rectangle {
+                        x: f64::from(i * i + 3 * i) / 2.0 + 2.0,
+                        y: 2.0,
+                        width: f64::from(i),
+                        height: f64::from(i),
+                        color: Color::Red,
+                    });
+                    ctx.draw(&Rectangle {
+                        x: f64::from(i * i + 3 * i) / 2.0 + 2.0,
+                        y: 21.0,
+                        width: f64::from(i),
+                        height: f64::from(i),
+                        color: Color::Blue,
+                    });
+                }
+                for i in 0..100 {
+                    if i % 10 != 0 {
+                        ctx.print(f64::from(i) + 1.0, 0.0, format!("{i}", i = i % 10));
+                    }
+                    if i % 2 == 0 && i % 10 != 0 {
+                        ctx.print(0.0, f64::from(i), format!("{i}", i = i % 10));
+                    }
+                }
+            })
+    }
+}

examples/apps/chart/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "chart"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm.workspace = true
+ratatui.workspace = true
+
+[lints]
+workspace = true

examples/apps/chart/README.md

@@ -0,0 +1,9 @@
+# Chart demo
+
+This example shows how to render line, bar, and scatter charts.
+
+To run this demo:
+
+```shell
+cargo run -p chart
+```

examples/apps/chart/src/main.rs

@@ -0,0 +1,352 @@
+/// A Ratatui example that demonstrates how to handle charts.
+///
+/// This example demonstrates how to draw various types of charts such as line, bar, and
+/// scatter charts.
+///
+/// This example runs with the Ratatui library code in the branch that you are currently
+/// reading. See the [`latest`] branch for the code which works with the most recent Ratatui
+/// release.
+///
+/// [`latest`]: https://github.com/ratatui/ratatui/tree/latest
+use std::time::{Duration, Instant};
+
+use color_eyre::Result;
+use crossterm::event::{self, KeyCode};
+use ratatui::layout::{Constraint, Layout, Rect};
+use ratatui::style::{Color, Modifier, Style, Stylize};
+use ratatui::symbols::{self, Marker};
+use ratatui::text::{Line, Span};
+use ratatui::widgets::{Axis, Block, Chart, Dataset, GraphType, LegendPosition};
+use ratatui::{DefaultTerminal, Frame};
+
+fn main() -> Result<()> {
+    color_eyre::install()?;
+    ratatui::run(|terminal| App::new().run(terminal))
+}
+
+struct App {
+    signal1: SinSignal,
+    data1: Vec<(f64, f64)>,
+    signal2: SinSignal,
+    data2: Vec<(f64, f64)>,
+    window: [f64; 2],
+}
+
+#[derive(Clone)]
+struct SinSignal {
+    x: f64,
+    interval: f64,
+    period: f64,
+    scale: f64,
+}
+
+impl SinSignal {
+    const fn new(interval: f64, period: f64, scale: f64) -> Self {
+        Self {
+            x: 0.0,
+            interval,
+            period,
+            scale,
+        }
+    }
+}
+
+impl Iterator for SinSignal {
+    type Item = (f64, f64);
+    fn next(&mut self) -> Option<Self::Item> {
+        let point = (self.x, (self.x * 1.0 / self.period).sin() * self.scale);
+        self.x += self.interval;
+        Some(point)
+    }
+}
+
+impl App {
+    fn new() -> Self {
+        let mut signal1 = SinSignal::new(0.2, 3.0, 18.0);
+        let mut signal2 = SinSignal::new(0.1, 2.0, 10.0);
+        let data1 = signal1.by_ref().take(200).collect::<Vec<(f64, f64)>>();
+        let data2 = signal2.by_ref().take(200).collect::<Vec<(f64, f64)>>();
+        Self {
+            signal1,
+            data1,
+            signal2,
+            data2,
+            window: [0.0, 20.0],
+        }
+    }
+
+    fn run(mut self, terminal: &mut DefaultTerminal) -> Result<()> {
+        let tick_rate = Duration::from_millis(250);
+        let mut last_tick = Instant::now();
+        loop {
+            terminal.draw(|frame| self.render(frame))?;
+
+            let timeout = tick_rate.saturating_sub(last_tick.elapsed());
+            if !event::poll(timeout)? {
+                self.on_tick();
+                last_tick = Instant::now();
+                continue;
+            }
+            if event::read()?
+                .as_key_press_event()
+                .is_some_and(|key| key.code == KeyCode::Char('q'))
+            {
+                return Ok(());
+            }
+        }
+    }
+
+    fn on_tick(&mut self) {
+        self.data1.drain(0..5);
+        self.data1.extend(self.signal1.by_ref().take(5));
+
+        self.data2.drain(0..10);
+        self.data2.extend(self.signal2.by_ref().take(10));
+
+        self.window[0] += 1.0;
+        self.window[1] += 1.0;
+    }
+
+    fn render(&self, frame: &mut Frame) {
+        let vertical = Layout::vertical([Constraint::Fill(1); 2]);
+        let [top, bottom] = frame.area().layout(&vertical);
+        let horizontal = Layout::horizontal([Constraint::Fill(1), Constraint::Length(29)]);
+        let [animated_chart, bar_chart] = top.layout(&horizontal);
+        let [line_chart, scatter] = bottom.layout(&Layout::horizontal([Constraint::Fill(1); 2]));
+
+        self.render_animated_chart(frame, animated_chart);
+        render_barchart(frame, bar_chart);
+        render_line_chart(frame, line_chart);
+        render_scatter(frame, scatter);
+    }
+
+    fn render_animated_chart(&self, frame: &mut Frame, area: Rect) {
+        let x_labels = vec![
+            Span::styled(
+                format!("{}", self.window[0]),
+                Style::default().add_modifier(Modifier::BOLD),
+            ),
+            Span::raw(format!("{}", f64::midpoint(self.window[0], self.window[1]))),
+            Span::styled(
+                format!("{}", self.window[1]),
+                Style::default().add_modifier(Modifier::BOLD),
+            ),
+        ];
+        let datasets = vec![
+            Dataset::default()
+                .name("data2")
+                .marker(symbols::Marker::Dot)
+                .style(Style::default().fg(Color::Cyan))
+                .data(&self.data1),
+            Dataset::default()
+                .name("data3")
+                .marker(symbols::Marker::Braille)
+                .style(Style::default().fg(Color::Yellow))
+                .data(&self.data2),
+        ];
+
+        let chart = Chart::new(datasets)
+            .block(Block::bordered())
+            .x_axis(
+                Axis::default()
+                    .title("X Axis")
+                    .style(Style::default().fg(Color::Gray))
+                    .labels(x_labels)
+                    .bounds(self.window),
+            )
+            .y_axis(
+                Axis::default()
+                    .title("Y Axis")
+                    .style(Style::default().fg(Color::Gray))
+                    .labels(["-20".bold(), "0".into(), "20".bold()])
+                    .bounds([-20.0, 20.0]),
+            );
+
+        frame.render_widget(chart, area);
+    }
+}
+
+fn render_barchart(frame: &mut Frame, bar_chart: Rect) {
+    let dataset = Dataset::default()
+        .marker(symbols::Marker::HalfBlock)
+        .style(Style::new().fg(Color::Blue))
+        .graph_type(GraphType::Bar)
+        // a bell curve
+        .data(&[
+            (0., 0.4),
+            (10., 2.9),
+            (20., 13.5),
+            (30., 41.1),
+            (40., 80.1),
+            (50., 100.0),
+            (60., 80.1),
+            (70., 41.1),
+            (80., 13.5),
+            (90., 2.9),
+            (100., 0.4),
+        ]);
+
+    let chart = Chart::new(vec![dataset])
+        .block(Block::bordered().title_top(Line::from("Bar chart").cyan().bold().centered()))
+        .x_axis(
+            Axis::default()
+                .style(Style::default().gray())
+                .bounds([0.0, 100.0])
+                .labels(["0".bold(), "50".into(), "100.0".bold()]),
+        )
+        .y_axis(
+            Axis::default()
+                .style(Style::default().gray())
+                .bounds([0.0, 100.0])
+                .labels(["0".bold(), "50".into(), "100.0".bold()]),
+        )
+        .hidden_legend_constraints((Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)));
+
+    frame.render_widget(chart, bar_chart);
+}
+
+fn render_line_chart(frame: &mut Frame, area: Rect) {
+    let datasets = vec![
+        Dataset::default()
+            .name("Line from only 2 points".italic())
+            .marker(symbols::Marker::Braille)
+            .style(Style::default().fg(Color::Yellow))
+            .graph_type(GraphType::Line)
+            .data(&[(1., 1.), (4., 4.)]),
+    ];
+
+    let chart = Chart::new(datasets)
+        .block(Block::bordered().title(Line::from("Line chart").cyan().bold().centered()))
+        .x_axis(
+            Axis::default()
+                .title("X Axis")
+                .style(Style::default().gray())
+                .bounds([0.0, 5.0])
+                .labels(["0".bold(), "2.5".into(), "5.0".bold()]),
+        )
+        .y_axis(
+            Axis::default()
+                .title("Y Axis")
+                .style(Style::default().gray())
+                .bounds([0.0, 5.0])
+                .labels(["0".bold(), "2.5".into(), "5.0".bold()]),
+        )
+        .legend_position(Some(LegendPosition::TopLeft))
+        .hidden_legend_constraints((Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)));
+
+    frame.render_widget(chart, area);
+}
+
+fn render_scatter(frame: &mut Frame, area: Rect) {
+    let datasets = vec![
+        Dataset::default()
+            .name("Heavy")
+            .marker(Marker::Dot)
+            .graph_type(GraphType::Scatter)
+            .style(Style::new().yellow())
+            .data(&HEAVY_PAYLOAD_DATA),
+        Dataset::default()
+            .name("Medium".underlined())
+            .marker(Marker::Braille)
+            .graph_type(GraphType::Scatter)
+            .style(Style::new().magenta())
+            .data(&MEDIUM_PAYLOAD_DATA),
+        Dataset::default()
+            .name("Small")
+            .marker(Marker::Dot)
+            .graph_type(GraphType::Scatter)
+            .style(Style::new().cyan())
+            .data(&SMALL_PAYLOAD_DATA),
+    ];
+
+    let chart = Chart::new(datasets)
+        .block(Block::bordered().title(Line::from("Scatter chart").cyan().bold().centered()))
+        .x_axis(
+            Axis::default()
+                .title("Year")
+                .bounds([1960., 2020.])
+                .style(Style::default().fg(Color::Gray))
+                .labels(["1960", "1990", "2020"]),
+        )
+        .y_axis(
+            Axis::default()
+                .title("Cost")
+                .bounds([0., 75000.])
+                .style(Style::default().fg(Color::Gray))
+                .labels(["0", "37 500", "75 000"]),
+        )
+        .hidden_legend_constraints((Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)));
+
+    frame.render_widget(chart, area);
+}
+
+// Data from https://ourworldindata.org/space-exploration-satellites
+const HEAVY_PAYLOAD_DATA: [(f64, f64); 9] = [
+    (1965., 8200.),
+    (1967., 5400.),
+    (1981., 65400.),
+    (1989., 30800.),
+    (1997., 10200.),
+    (2004., 11600.),
+    (2014., 4500.),
+    (2016., 7900.),
+    (2018., 1500.),
+];
+
+const MEDIUM_PAYLOAD_DATA: [(f64, f64); 29] = [
+    (1963., 29500.),
+    (1964., 30600.),
+    (1965., 177_900.),
+    (1965., 21000.),
+    (1966., 17900.),
+    (1966., 8400.),
+    (1975., 17500.),
+    (1982., 8300.),
+    (1985., 5100.),
+    (1988., 18300.),
+    (1990., 38800.),
+    (1990., 9900.),
+    (1991., 18700.),
+    (1992., 9100.),
+    (1994., 10500.),
+    (1994., 8500.),
+    (1994., 8700.),
+    (1997., 6200.),
+    (1999., 18000.),
+    (1999., 7600.),
+    (1999., 8900.),
+    (1999., 9600.),
+    (2000., 16000.),
+    (2001., 10000.),
+    (2002., 10400.),
+    (2002., 8100.),
+    (2010., 2600.),
+    (2013., 13600.),
+    (2017., 8000.),
+];
+
+const SMALL_PAYLOAD_DATA: [(f64, f64); 23] = [
+    (1961., 118_500.),
+    (1962., 14900.),
+    (1975., 21400.),
+    (1980., 32800.),
+    (1988., 31100.),
+    (1990., 41100.),
+    (1993., 23600.),
+    (1994., 20600.),
+    (1994., 34600.),
+    (1996., 50600.),
+    (1997., 19200.),
+    (1997., 45800.),
+    (1998., 19100.),
+    (2000., 73100.),
+    (2003., 11200.),
+    (2008., 12600.),
+    (2010., 30500.),
+    (2012., 20000.),
+    (2013., 10600.),
+    (2013., 34500.),
+    (2015., 10600.),
+    (2018., 23100.),
+    (2019., 17300.),
+];

examples/apps/color-explorer/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "color-explorer"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm.workspace = true
+itertools.workspace = true
+ratatui.workspace = true
+
+[lints]
+workspace = true

examples/apps/color-explorer/README.md

@@ -0,0 +1,9 @@
+# Color explorer demo
+
+This example shows how to handle the supported colors.
+
+To run this demo:
+
+```shell
+cargo run -p color-explorer
+```

examples/apps/color-explorer/src/main.rs

@@ -1,76 +1,45 @@
-//! # [Ratatui] Colors example
+//! A Ratatui example that demonstrates how to handle colors.
 //!
-//! The latest version of this example is available in the [examples] folder in the repository.
+//! This example shows all the colors supported by Ratatui. It will render a grid of foreground
+//! and background colors with their names and indexes.
 //!
-//! Please note that the examples are designed to be run against the `main` branch of the Github
-//! repository. This means that you may not be able to compile with the latest release version on
-//! crates.io, or the one that you have installed locally.
+//! This example runs with the Ratatui library code in the branch that you are currently reading.
+//! See the [`latest`] branch for the code which works with the most recent Ratatui release.
 //!
-//! See the [examples readme] for more information on finding examples that match the version of the
-//! library you are using.
-//!
-//! [Ratatui]: https://github.com/ratatui-org/ratatui
-//! [examples]: https://github.com/ratatui-org/ratatui/blob/main/examples
-//! [examples readme]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md
+//! [`latest`]: https://github.com/ratatui/ratatui/tree/latest
 
-// This example shows all the colors supported by ratatui. It will render a grid of foreground
-// and background colors with their names and indexes.
-
-use std::{
-    error::Error,
-    io::{self, Stdout},
-    result,
-    time::Duration,
-};
-
-use crossterm::{
-    event::{self, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
+use color_eyre::Result;
+use crossterm::event;
 use itertools::Itertools;
-use ratatui::{
-    prelude::*,
-    widgets::{Block, Borders, Paragraph},
-};
-
-type Result<T> = result::Result<T, Box<dyn Error>>;
+use ratatui::Frame;
+use ratatui::layout::{Alignment, Constraint, Layout, Rect};
+use ratatui::style::{Color, Style, Stylize};
+use ratatui::text::Line;
+use ratatui::widgets::{Block, Borders, Paragraph};
 
 fn main() -> Result<()> {
-    let mut terminal = setup_terminal()?;
-    let res = run_app(&mut terminal);
-    restore_terminal(terminal)?;
-    if let Err(err) = res {
-        eprintln!("{err:?}");
-    }
-    Ok(())
-}
-
-fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> io::Result<()> {
-    loop {
-        terminal.draw(ui)?;
-
-        if event::poll(Duration::from_millis(250))? {
-            if let Event::Key(key) = event::read()? {
-                if key.code == KeyCode::Char('q') {
-                    return Ok(());
-                }
+    color_eyre::install()?;
+    ratatui::run(|terminal| {
+        loop {
+            terminal.draw(render)?;
+            if event::read()?.is_key_press() {
+                return Ok(());
             }
         }
-    }
+    })
 }
 
-fn ui(frame: &mut Frame) {
-    let layout = Layout::vertical([
+fn render(frame: &mut Frame) {
+    let [named, indexed_colors, indexed_greys] = Layout::vertical([
         Constraint::Length(30),
         Constraint::Length(17),
         Constraint::Length(2),
     ])
-    .split(frame.size());
+    .areas(frame.area());
 
-    render_named_colors(frame, layout[0]);
-    render_indexed_colors(frame, layout[1]);
-    render_indexed_grayscale(frame, layout[2]);
+    render_named_colors(frame, named);
+    render_indexed_colors(frame, indexed_colors);
+    render_indexed_grayscale(frame, indexed_greys);
 }
 
 const NAMED_COLORS: [Color; 16] = [
@@ -113,19 +82,16 @@ fn render_fg_named_colors(frame: &mut Frame, bg: Color, area: Rect) {
     let inner = block.inner(area);
     frame.render_widget(block, area);
 
-    let layout = Layout::vertical([Constraint::Length(1); 2])
-        .split(inner)
-        .iter()
-        .flat_map(|area| {
-            Layout::horizontal([Constraint::Ratio(1, 8); 8])
-                .split(*area)
-                .to_vec()
-        })
-        .collect_vec();
-    for (i, &fg) in NAMED_COLORS.iter().enumerate() {
+    let vertical = Layout::vertical([Constraint::Length(1); 2]);
+    let horizontal = Layout::horizontal([Constraint::Ratio(1, 8); 8]);
+    let areas = inner
+        .layout_vec(&vertical)
+        .into_iter()
+        .flat_map(|area| area.layout_vec(&horizontal));
+    for (fg, area) in NAMED_COLORS.into_iter().zip(areas) {
         let color_name = fg.to_string();
         let paragraph = Paragraph::new(color_name).fg(fg).bg(bg);
-        frame.render_widget(paragraph, layout[i]);
+        frame.render_widget(paragraph, area);
     }
 }
 
@@ -134,19 +100,16 @@ fn render_bg_named_colors(frame: &mut Frame, fg: Color, area: Rect) {
     let inner = block.inner(area);
     frame.render_widget(block, area);
 
-    let layout = Layout::vertical([Constraint::Length(1); 2])
-        .split(inner)
-        .iter()
-        .flat_map(|area| {
-            Layout::horizontal([Constraint::Ratio(1, 8); 8])
-                .split(*area)
-                .to_vec()
-        })
-        .collect_vec();
-    for (i, &bg) in NAMED_COLORS.iter().enumerate() {
+    let vertical = Layout::vertical([Constraint::Length(1); 2]);
+    let horizontal = Layout::horizontal([Constraint::Ratio(1, 8); 8]);
+    let areas = inner
+        .layout_vec(&vertical)
+        .into_iter()
+        .flat_map(|area| area.layout_vec(&horizontal));
+    for (bg, area) in NAMED_COLORS.into_iter().zip(areas) {
         let color_name = bg.to_string();
         let paragraph = Paragraph::new(color_name).fg(fg).bg(bg);
-        frame.render_widget(paragraph, layout[i]);
+        frame.render_widget(paragraph, area);
     }
 }
 
@@ -234,7 +197,7 @@ fn title_block(title: String) -> Block<'static> {
         .borders(Borders::TOP)
         .title_alignment(Alignment::Center)
         .border_style(Style::new().dark_gray())
-        .title_style(Style::new().reset())
+        .title_style(Style::reset())
         .title(title)
 }
 
@@ -267,20 +230,3 @@ fn render_indexed_grayscale(frame: &mut Frame, area: Rect) {
         frame.render_widget(paragraph, layout[i as usize - 232]);
     }
 }
-
-fn setup_terminal() -> Result<Terminal<CrosstermBackend<Stdout>>> {
-    enable_raw_mode()?;
-    let mut stdout = io::stdout();
-    execute!(stdout, EnterAlternateScreen)?;
-    let backend = CrosstermBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
-    terminal.hide_cursor()?;
-    Ok(terminal)
-}
-
-fn restore_terminal(mut terminal: Terminal<CrosstermBackend<Stdout>>) -> Result<()> {
-    disable_raw_mode()?;
-    execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-    terminal.show_cursor()?;
-    Ok(())
-}

examples/apps/colors-rgb/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "colors-rgb"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm.workspace = true
+palette.workspace = true
+ratatui.workspace = true
+
+[lints]
+workspace = true

examples/apps/colors-rgb/README.md

@@ -0,0 +1,9 @@
+# Colors-RGB demo
+
+This example shows the full range of RGB colors in an animation.
+
+To run this demo:
+
+```shell
+cargo run -p colors-rgb
+```

examples/apps/colors-rgb/src/main.rs

@@ -1,45 +1,38 @@
-//! # [Ratatui] `Colors_RGB` example
+//! A Ratatui example that shows the full range of RGB colors that can be displayed in the terminal.
 //!
-//! The latest version of this example is available in the [examples] folder in the repository.
+//! Requires a terminal that supports 24-bit color (true color) and unicode.
 //!
-//! Please note that the examples are designed to be run against the `main` branch of the Github
-//! repository. This means that you may not be able to compile with the latest release version on
-//! crates.io, or the one that you have installed locally.
+//! This example also demonstrates how implementing the Widget trait on a mutable reference
+//! allows the widget to update its state while it is being rendered. This allows the fps
+//! widget to update the fps calculation and the colors widget to update a cached version of
+//! the colors to render instead of recalculating them every frame.
 //!
-//! See the [examples readme] for more information on finding examples that match the version of the
-//! library you are using.
+//! This is an alternative to using the `StatefulWidget` trait and a separate state struct. It
+//! is useful when the state is only used by the widget and doesn't need to be shared with
+//! other widgets.
 //!
-//! [Ratatui]: https://github.com/ratatui-org/ratatui
-//! [examples]: https://github.com/ratatui-org/ratatui/blob/main/examples
-//! [examples readme]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md
+//! This example runs with the Ratatui library code in the branch that you are currently reading.
+//! See the [`latest`] branch for the code which works with the most recent Ratatui release.
+//!
+//! [`latest`]: https://github.com/ratatui/ratatui/tree/latest
 
-// This example shows the full range of RGB colors that can be displayed in the terminal.
-//
-// Requires a terminal that supports 24-bit color (true color) and unicode.
-//
-// This example also demonstrates how implementing the Widget trait on a mutable reference
-// allows the widget to update its state while it is being rendered. This allows the fps
-// widget to update the fps calculation and the colors widget to update a cached version of
-// the colors to render instead of recalculating them every frame.
-//
-// This is an alternative to using the `StatefulWidget` trait and a separate state struct. It
-// is useful when the state is only used by the widget and doesn't need to be shared with
-// other widgets.
+use std::time::{Duration, Instant};
 
-use std::{
-    io::stdout,
-    panic,
-    time::{Duration, Instant},
-};
+use color_eyre::Result;
+use crossterm::event;
+use palette::convert::FromColorUnclamped;
+use palette::{Okhsv, Srgb};
+use ratatui::DefaultTerminal;
+use ratatui::buffer::Buffer;
+use ratatui::layout::{Constraint, Layout, Position, Rect};
+use ratatui::style::Color;
+use ratatui::text::Text;
+use ratatui::widgets::Widget;
 
-use color_eyre::{config::HookBuilder, eyre, Result};
-use crossterm::{
-    event::{self, Event, KeyCode, KeyEventKind},
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    ExecutableCommand,
-};
-use palette::{convert::FromColorUnclamped, Okhsv, Srgb};
-use ratatui::prelude::*;
+fn main() -> Result<()> {
+    color_eyre::install()?;
+    ratatui::run(|terminal| App::default().run(terminal))
+}
 
 #[derive(Debug, Default)]
 struct App {
@@ -91,21 +84,13 @@ struct ColorsWidget {
     frame_count: usize,
 }
 
-fn main() -> Result<()> {
-    install_error_hooks()?;
-    let terminal = init_terminal()?;
-    App::default().run(terminal)?;
-    restore_terminal()?;
-    Ok(())
-}
-
 impl App {
     /// Run the app
     ///
     /// This is the main event loop for the app.
-    pub fn run(mut self, mut terminal: Terminal<impl Backend>) -> Result<()> {
+    pub fn run(mut self, terminal: &mut DefaultTerminal) -> Result<()> {
         while self.is_running() {
-            terminal.draw(|frame| frame.render_widget(&mut self, frame.size()))?;
+            terminal.draw(|frame| frame.render_widget(&mut self, frame.area()))?;
             self.handle_events()?;
         }
         Ok(())
@@ -116,19 +101,16 @@ impl App {
     }
 
     /// Handle any events that have occurred since the last time the app was rendered.
-    ///
-    /// Currently, this only handles the q key to quit the app.
     fn handle_events(&mut self) -> Result<()> {
         // Ensure that the app only blocks for a period that allows the app to render at
         // approximately 60 FPS (this doesn't account for the time to render the frame, and will
         // also update the app immediately any time an event occurs)
         let timeout = Duration::from_secs_f32(1.0 / 60.0);
-        if event::poll(timeout)? {
-            if let Event::Key(key) = event::read()? {
-                if key.kind == KeyEventKind::Press && key.code == KeyCode::Char('q') {
-                    self.state = AppState::Quit;
-                };
-            }
+        if !event::poll(timeout)? {
+            return Ok(());
+        }
+        if event::read()?.is_key_press() {
+            self.state = AppState::Quit;
         }
         Ok(())
     }
@@ -141,10 +123,9 @@ impl App {
 /// to update the colors to render.
 impl Widget for &mut App {
     fn render(self, area: Rect, buf: &mut Buffer) {
-        #[allow(clippy::enum_glob_use)]
-        use Constraint::*;
-        let [top, colors] = Layout::vertical([Length(1), Min(0)]).areas(area);
-        let [title, fps] = Layout::horizontal([Min(0), Length(8)]).areas(top);
+        use Constraint::{Length, Min};
+        let [top, colors] = area.layout(&Layout::vertical([Length(1), Min(0)]));
+        let [title, fps] = top.layout(&Layout::horizontal([Min(0), Length(8)]));
         Text::from("colors_rgb example. Press q to quit")
             .centered()
             .render(title, buf);
@@ -187,7 +168,7 @@ impl FpsWidget {
     /// This updates the fps once a second, but only if the widget has rendered at least 2 frames
     /// since the last calculation. This avoids noise in the fps calculation when rendering on slow
     /// machines that can't render at least 2 frames per second.
-    #[allow(clippy::cast_precision_loss)]
+    #[expect(clippy::cast_precision_loss)]
     fn calculate_fps(&mut self) {
         self.frame_count += 1;
         let elapsed = self.last_instant.elapsed();
@@ -217,7 +198,7 @@ impl Widget for &mut ColorsWidget {
                 // pixel below it
                 let fg = colors[yi * 2][xi];
                 let bg = colors[yi * 2 + 1][xi];
-                buf.get_mut(x, y).set_char('▀').set_fg(fg).set_bg(bg);
+                buf[Position::new(x, y)].set_char('▀').set_fg(fg).set_bg(bg);
             }
         }
         self.frame_count += 1;
@@ -229,7 +210,7 @@ impl ColorsWidget {
     ///
     /// This is called once per frame to setup the colors to render. It caches the colors so that
     /// they don't need to be recalculated every frame.
-    #[allow(clippy::cast_precision_loss)]
+    #[expect(clippy::cast_precision_loss)]
     fn setup_colors(&mut self, size: Rect) {
         let Rect { width, height, .. } = size;
         // double the height because each screen row has two rows of half block pixels
@@ -256,36 +237,3 @@ impl ColorsWidget {
         }
     }
 }
-
-/// Install `color_eyre` panic and error hooks
-///
-/// The hooks restore the terminal to a usable state before printing the error message.
-fn install_error_hooks() -> Result<()> {
-    let (panic, error) = HookBuilder::default().into_hooks();
-    let panic = panic.into_panic_hook();
-    let error = error.into_eyre_hook();
-    eyre::set_hook(Box::new(move |e| {
-        let _ = restore_terminal();
-        error(e)
-    }))?;
-    panic::set_hook(Box::new(move |info| {
-        let _ = restore_terminal();
-        panic(info);
-    }));
-    Ok(())
-}
-
-fn init_terminal() -> Result<Terminal<impl Backend>> {
-    enable_raw_mode()?;
-    stdout().execute(EnterAlternateScreen)?;
-    let mut terminal = Terminal::new(CrosstermBackend::new(stdout()))?;
-    terminal.clear()?;
-    terminal.hide_cursor()?;
-    Ok(terminal)
-}
-
-fn restore_terminal() -> Result<()> {
-    disable_raw_mode()?;
-    stdout().execute(LeaveAlternateScreen)?;
-    Ok(())
-}

examples/apps/constraint-explorer/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "constraint-explorer"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm.workspace = true
+itertools.workspace = true
+ratatui.workspace = true
+strum.workspace = true
+
+[lints]
+workspace = true

examples/apps/constraint-explorer/README.md

@@ -0,0 +1,9 @@
+# Constraint explorer demo
+
+This interactive example shows how different constraints can be used to layout widgets.
+
+To run this demo:
+
+```shell
+cargo run -p constraint-explorer
+```

examples/apps/constraint-explorer/src/main.rs

@@ -1,38 +1,32 @@
-//! # [Ratatui] Constraint explorer example
-//!
-//! The latest version of this example is available in the [examples] folder in the repository.
-//!
-//! Please note that the examples are designed to be run against the `main` branch of the Github
-//! repository. This means that you may not be able to compile with the latest release version on
-//! crates.io, or the one that you have installed locally.
-//!
-//! See the [examples readme] for more information on finding examples that match the version of the
-//! library you are using.
-//!
-//! [Ratatui]: https://github.com/ratatui-org/ratatui
-//! [examples]: https://github.com/ratatui-org/ratatui/blob/main/examples
-//! [examples readme]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md
-
-#![allow(clippy::enum_glob_use, clippy::wildcard_imports)]
-
-use std::io::{self, stdout};
-
-use color_eyre::{config::HookBuilder, Result};
-use crossterm::{
-    event::{self, Event, KeyCode, KeyEventKind},
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    ExecutableCommand,
-};
+/// A Ratatui example that demonstrates how different layout constraints work.
+///
+/// It also supports swapping constraints, adding and removing blocks, and changing the spacing
+/// between blocks.
+///
+/// This example runs with the Ratatui library code in the branch that you are currently
+/// reading. See the [`latest`] branch for the code which works with the most recent Ratatui
+/// release.
+///
+/// [`latest`]: https://github.com/ratatui/ratatui/tree/latest
+use color_eyre::Result;
+use crossterm::event::{self, KeyCode};
 use itertools::Itertools;
-use ratatui::{
-    layout::{Constraint::*, Flex},
-    prelude::*,
-    style::palette::tailwind::*,
-    symbols::line,
-    widgets::{Block, Paragraph, Wrap},
-};
+use ratatui::DefaultTerminal;
+use ratatui::buffer::Buffer;
+use ratatui::layout::Constraint::{self, Fill, Length, Max, Min, Percentage, Ratio};
+use ratatui::layout::{Flex, Layout, Rect};
+use ratatui::style::palette::tailwind::{BLUE, SKY, SLATE, STONE};
+use ratatui::style::{Color, Style, Stylize};
+use ratatui::symbols::{self, line};
+use ratatui::text::{Line, Span, Text};
+use ratatui::widgets::{Block, Paragraph, Widget, Wrap};
 use strum::{Display, EnumIter, FromRepr};
 
+fn main() -> Result<()> {
+    color_eyre::install()?;
+    ratatui::run(|terminal| App::default().run(terminal))
+}
+
 #[derive(Default)]
 struct App {
     mode: AppMode,
@@ -83,21 +77,13 @@ struct ConstraintBlock {
 /// ```
 struct SpacerBlock;
 
-fn main() -> Result<()> {
-    init_error_hooks()?;
-    let terminal = init_terminal()?;
-    App::default().run(terminal)?;
-    restore_terminal()?;
-    Ok(())
-}
-
 // App behaviour
 impl App {
-    fn run(&mut self, mut terminal: Terminal<impl Backend>) -> Result<()> {
+    fn run(mut self, terminal: &mut DefaultTerminal) -> Result<()> {
         self.insert_test_defaults();
 
         while self.is_running() {
-            self.draw(&mut terminal)?;
+            terminal.draw(|frame| frame.render_widget(&self, frame.area()))?;
             self.handle_events()?;
         }
         Ok(())
@@ -117,33 +103,26 @@ impl App {
         self.mode == AppMode::Running
     }
 
-    fn draw(&self, terminal: &mut Terminal<impl Backend>) -> io::Result<()> {
-        terminal.draw(|frame| frame.render_widget(self, frame.size()))?;
-        Ok(())
-    }
-
     fn handle_events(&mut self) -> Result<()> {
-        use KeyCode::*;
-        match event::read()? {
-            Event::Key(key) if key.kind == KeyEventKind::Press => match key.code {
-                Char('q') | Esc => self.exit(),
-                Char('1') => self.swap_constraint(ConstraintName::Min),
-                Char('2') => self.swap_constraint(ConstraintName::Max),
-                Char('3') => self.swap_constraint(ConstraintName::Length),
-                Char('4') => self.swap_constraint(ConstraintName::Percentage),
-                Char('5') => self.swap_constraint(ConstraintName::Ratio),
-                Char('6') => self.swap_constraint(ConstraintName::Fill),
-                Char('+') => self.increment_spacing(),
-                Char('-') => self.decrement_spacing(),
-                Char('x') => self.delete_block(),
-                Char('a') => self.insert_block(),
-                Char('k') | Up => self.increment_value(),
-                Char('j') | Down => self.decrement_value(),
-                Char('h') | Left => self.prev_block(),
-                Char('l') | Right => self.next_block(),
+        if let Some(key) = event::read()?.as_key_press_event() {
+            match key.code {
+                KeyCode::Char('q') | KeyCode::Esc => self.exit(),
+                KeyCode::Char('1') => self.swap_constraint(ConstraintName::Min),
+                KeyCode::Char('2') => self.swap_constraint(ConstraintName::Max),
+                KeyCode::Char('3') => self.swap_constraint(ConstraintName::Length),
+                KeyCode::Char('4') => self.swap_constraint(ConstraintName::Percentage),
+                KeyCode::Char('5') => self.swap_constraint(ConstraintName::Ratio),
+                KeyCode::Char('6') => self.swap_constraint(ConstraintName::Fill),
+                KeyCode::Char('+') => self.increment_spacing(),
+                KeyCode::Char('-') => self.decrement_spacing(),
+                KeyCode::Char('x') => self.delete_block(),
+                KeyCode::Char('a') => self.insert_block(),
+                KeyCode::Char('k') | KeyCode::Up => self.increment_value(),
+                KeyCode::Char('j') | KeyCode::Down => self.decrement_value(),
+                KeyCode::Char('h') | KeyCode::Left => self.prev_block(),
+                KeyCode::Char('l') | KeyCode::Right => self.next_block(),
                 _ => {}
-            },
-            _ => {}
+            }
         }
         Ok(())
     }
@@ -159,7 +138,7 @@ impl App {
             | Constraint::Fill(v)
             | Constraint::Percentage(v) => *v = v.saturating_add(1),
             Constraint::Ratio(_n, d) => *d = d.saturating_add(1),
-        };
+        }
     }
 
     fn decrement_value(&mut self) {
@@ -173,7 +152,7 @@ impl App {
             | Constraint::Fill(v)
             | Constraint::Percentage(v) => *v = v.saturating_sub(1),
             Constraint::Ratio(_n, d) => *d = d.saturating_sub(1),
-        };
+        }
     }
 
     /// select the next block with wrap around
@@ -214,15 +193,15 @@ impl App {
         self.selected_index = index;
     }
 
-    fn increment_spacing(&mut self) {
+    const fn increment_spacing(&mut self) {
         self.spacing = self.spacing.saturating_add(1);
     }
 
-    fn decrement_spacing(&mut self) {
+    const fn decrement_spacing(&mut self) {
         self.spacing = self.spacing.saturating_sub(1);
     }
 
-    fn exit(&mut self) {
+    const fn exit(&mut self) {
         self.mode = AppMode::Quit;
     }
 
@@ -257,15 +236,19 @@ impl From<Constraint> for ConstraintName {
 
 impl Widget for &App {
     fn render(self, area: Rect, buf: &mut Buffer) {
-        let [header_area, instructions_area, swap_legend_area, _, blocks_area] =
-            Layout::vertical([
-                Length(2), // header
-                Length(2), // instructions
-                Length(1), // swap key legend
-                Length(1), // gap
-                Fill(1),   // blocks
-            ])
-            .areas(area);
+        let [
+            header_area,
+            instructions_area,
+            swap_legend_area,
+            _,
+            blocks_area,
+        ] = area.layout(&Layout::vertical([
+            Length(2), // header
+            Length(2), // instructions
+            Length(1), // swap key legend
+            Length(1), // gap
+            Fill(1),   // blocks
+        ]));
 
         App::header().render(header_area, buf);
         App::instructions().render(instructions_area, buf);
@@ -294,7 +277,7 @@ impl App {
     }
 
     fn swap_legend() -> impl Widget {
-        #[allow(unstable_name_collisions)]
+        #[expect(unstable_name_collisions)]
         Paragraph::new(
             Line::from(
                 [
@@ -335,30 +318,31 @@ impl App {
     }
 
     fn render_layout_blocks(&self, area: Rect, buf: &mut Buffer) {
-        let [user_constraints, area] = Layout::vertical([Length(3), Fill(1)])
-            .spacing(1)
-            .areas(area);
+        let main_layout = Layout::vertical([Length(3), Fill(1)]).spacing(1);
+        let [user_constraints, area] = area.layout(&main_layout);
 
         self.render_user_constraints_legend(user_constraints, buf);
 
-        let [start, center, end, space_around, space_between] =
-            Layout::vertical([Length(7); 5]).areas(area);
+        let [
+            start,
+            center,
+            end,
+            space_between,
+            space_around,
+            space_evenly,
+        ] = area.layout(&Layout::vertical([Length(7); 6]));
 
         self.render_layout_block(Flex::Start, start, buf);
         self.render_layout_block(Flex::Center, center, buf);
         self.render_layout_block(Flex::End, end, buf);
-        self.render_layout_block(Flex::SpaceAround, space_around, buf);
         self.render_layout_block(Flex::SpaceBetween, space_between, buf);
+        self.render_layout_block(Flex::SpaceAround, space_around, buf);
+        self.render_layout_block(Flex::SpaceEvenly, space_evenly, buf);
     }
 
     fn render_user_constraints_legend(&self, area: Rect, buf: &mut Buffer) {
-        let blocks = Layout::horizontal(
-            self.constraints
-                .iter()
-                .map(|_| Constraint::Fill(1))
-                .collect_vec(),
-        )
-        .split(area);
+        let constraints = self.constraints.iter().map(|_| Constraint::Fill(1));
+        let blocks = Layout::horizontal(constraints).split(area);
 
         for (i, (area, constraint)) in blocks.iter().zip(self.constraints.iter()).enumerate() {
             let selected = self.selected_index == i;
@@ -367,8 +351,8 @@ impl App {
     }
 
     fn render_layout_block(&self, flex: Flex, area: Rect, buf: &mut Buffer) {
-        let [label_area, axis_area, blocks_area] =
-            Layout::vertical([Length(1), Max(1), Length(4)]).areas(area);
+        let layout = Layout::vertical([Length(1), Max(1), Length(4)]);
+        let [label_area, axis_area, blocks_area] = area.layout(&layout);
 
         if label_area.height > 0 {
             format!("Flex::{flex:?}").bold().render(label_area, buf);
@@ -488,7 +472,7 @@ impl ConstraintBlock {
             } else {
                 main_color
             };
-            if let Some(last_row) = area.rows().last() {
+            if let Some(last_row) = area.rows().next_back() {
                 buf.set_style(last_row, border_color);
             }
         }
@@ -615,32 +599,3 @@ impl ConstraintName {
         }
     }
 }
-
-fn init_error_hooks() -> Result<()> {
-    let (panic, error) = HookBuilder::default().into_hooks();
-    let panic = panic.into_panic_hook();
-    let error = error.into_eyre_hook();
-    color_eyre::eyre::set_hook(Box::new(move |e| {
-        let _ = restore_terminal();
-        error(e)
-    }))?;
-    std::panic::set_hook(Box::new(move |info| {
-        let _ = restore_terminal();
-        panic(info);
-    }));
-    Ok(())
-}
-
-fn init_terminal() -> Result<Terminal<impl Backend>> {
-    enable_raw_mode()?;
-    stdout().execute(EnterAlternateScreen)?;
-    let backend = CrosstermBackend::new(stdout());
-    let terminal = Terminal::new(backend)?;
-    Ok(terminal)
-}
-
-fn restore_terminal() -> Result<()> {
-    disable_raw_mode()?;
-    stdout().execute(LeaveAlternateScreen)?;
-    Ok(())
-}

examples/apps/constraints/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "constraints"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm.workspace = true
+ratatui.workspace = true
+strum.workspace = true
+
+[lints]
+workspace = true

examples/apps/constraints/README.md

@@ -0,0 +1,9 @@
+# Constraints demo
+
+This example shows different types of constraints.
+
+To run this demo:
+
+```shell
+cargo run -p constraints
+```

examples/apps/constraints/src/main.rs

@@ -1,29 +1,23 @@
-//! # [Ratatui] Constraints example
-//!
-//! The latest version of this example is available in the [examples] folder in the repository.
-//!
-//! Please note that the examples are designed to be run against the `main` branch of the Github
-//! repository. This means that you may not be able to compile with the latest release version on
-//! crates.io, or the one that you have installed locally.
-//!
-//! See the [examples readme] for more information on finding examples that match the version of the
-//! library you are using.
-//!
-//! [Ratatui]: https://github.com/ratatui-org/ratatui
-//! [examples]: https://github.com/ratatui-org/ratatui/blob/main/examples
-//! [examples readme]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md
-
-#![allow(clippy::enum_glob_use, clippy::wildcard_imports)]
-
-use std::io::{self, stdout};
-
-use color_eyre::{config::HookBuilder, Result};
-use crossterm::{
-    event::{self, Event, KeyCode, KeyEventKind},
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    ExecutableCommand,
+/// A Ratatui example that demonstrates different types of constraints.
+///
+/// This example runs with the Ratatui library code in the branch that you are currently
+/// reading. See the [`latest`] branch for the code which works with the most recent Ratatui
+/// release.
+///
+/// [`latest`]: https://github.com/ratatui/ratatui/tree/latest
+use color_eyre::Result;
+use crossterm::event::{self, KeyCode};
+use ratatui::buffer::Buffer;
+use ratatui::layout::Constraint::{self, Fill, Length, Max, Min, Percentage, Ratio};
+use ratatui::layout::{Layout, Rect};
+use ratatui::style::palette::tailwind;
+use ratatui::style::{Color, Modifier, Style, Stylize};
+use ratatui::text::Line;
+use ratatui::widgets::{
+    Block, Padding, Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState, StatefulWidget,
+    Tabs, Widget,
 };
-use ratatui::{layout::Constraint::*, prelude::*, style::palette::tailwind, widgets::*};
+use ratatui::{DefaultTerminal, symbols};
 use strum::{Display, EnumIter, FromRepr, IntoEnumIterator};
 
 const SPACER_HEIGHT: u16 = 0;
@@ -40,6 +34,11 @@ const RATIO_COLOR: Color = tailwind::SLATE.c900;
 // priority 4
 const FILL_COLOR: Color = tailwind::SLATE.c950;
 
+fn main() -> Result<()> {
+    color_eyre::install()?;
+    ratatui::run(|terminal| App::default().run(terminal))
+}
+
 #[derive(Default, Clone, Copy)]
 struct App {
     selected_tab: SelectedTab,
@@ -69,31 +68,17 @@ enum AppState {
     Quit,
 }
 
-fn main() -> Result<()> {
-    init_error_hooks()?;
-    let terminal = init_terminal()?;
-
-    // increase the cache size to avoid flickering for indeterminate layouts
-    Layout::init_cache(100);
-
-    App::default().run(terminal)?;
-
-    restore_terminal()?;
-
-    Ok(())
-}
-
 impl App {
-    fn run(&mut self, mut terminal: Terminal<impl Backend>) -> Result<()> {
+    fn run(mut self, terminal: &mut DefaultTerminal) -> Result<()> {
         self.update_max_scroll_offset();
         while self.is_running() {
-            self.draw(&mut terminal)?;
+            terminal.draw(|frame| frame.render_widget(self, frame.area()))?;
             self.handle_events()?;
         }
         Ok(())
     }
 
-    fn update_max_scroll_offset(&mut self) {
+    const fn update_max_scroll_offset(&mut self) {
         self.max_scroll_offset = (self.selected_tab.get_example_count() - 1) * EXAMPLE_HEIGHT;
     }
 
@@ -101,32 +86,23 @@ impl App {
         self.state == AppState::Running
     }
 
-    fn draw(self, terminal: &mut Terminal<impl Backend>) -> io::Result<()> {
-        terminal.draw(|frame| frame.render_widget(self, frame.size()))?;
-        Ok(())
-    }
-
     fn handle_events(&mut self) -> Result<()> {
-        if let Event::Key(key) = event::read()? {
-            use KeyCode::*;
-            if key.kind != KeyEventKind::Press {
-                return Ok(());
-            }
+        if let Some(key) = event::read()?.as_key_press_event() {
             match key.code {
-                Char('q') | Esc => self.quit(),
-                Char('l') | Right => self.next(),
-                Char('h') | Left => self.previous(),
-                Char('j') | Down => self.down(),
-                Char('k') | Up => self.up(),
-                Char('g') | Home => self.top(),
-                Char('G') | End => self.bottom(),
+                KeyCode::Char('q') | KeyCode::Esc => self.quit(),
+                KeyCode::Char('l') | KeyCode::Right => self.next(),
+                KeyCode::Char('h') | KeyCode::Left => self.previous(),
+                KeyCode::Char('j') | KeyCode::Down => self.down(),
+                KeyCode::Char('k') | KeyCode::Up => self.up(),
+                KeyCode::Char('g') | KeyCode::Home => self.top(),
+                KeyCode::Char('G') | KeyCode::End => self.bottom(),
                 _ => (),
             }
         }
         Ok(())
     }
 
-    fn quit(&mut self) {
+    const fn quit(&mut self) {
         self.state = AppState::Quit;
     }
 
@@ -142,7 +118,7 @@ impl App {
         self.scroll_offset = 0;
     }
 
-    fn up(&mut self) {
+    const fn up(&mut self) {
         self.scroll_offset = self.scroll_offset.saturating_sub(1);
     }
 
@@ -153,18 +129,18 @@ impl App {
             .min(self.max_scroll_offset);
     }
 
-    fn top(&mut self) {
+    const fn top(&mut self) {
         self.scroll_offset = 0;
     }
 
-    fn bottom(&mut self) {
+    const fn bottom(&mut self) {
         self.scroll_offset = self.max_scroll_offset;
     }
 }
 
 impl Widget for App {
     fn render(self, area: Rect, buf: &mut Buffer) {
-        let [tabs, axis, demo] = Layout::vertical([Length(3), Length(3), Fill(0)]).areas(area);
+        let [tabs, axis, demo] = area.layout(&Layout::vertical([Length(3), Length(3), Fill(0)]));
 
         self.render_tabs(tabs, buf);
         Self::render_axis(axis, buf);
@@ -210,7 +186,7 @@ impl App {
     ///
     /// This function renders the demo content into a separate buffer and then splices the buffer
     /// into the main buffer. This is done to make it possible to handle scrolling easily.
-    #[allow(clippy::cast_possible_truncation)]
+    #[expect(clippy::cast_possible_truncation)]
     fn render_demo(self, area: Rect, buf: &mut Buffer) {
         // render demo content into a separate buffer so all examples fit we add an extra
         // area.height to make sure the last example is fully visible even when the scroll offset is
@@ -238,7 +214,7 @@ impl App {
         for (i, cell) in visible_content.enumerate() {
             let x = i as u16 % area.width;
             let y = i as u16 / area.width;
-            *buf.get_mut(area.x + x, area.y + y) = cell;
+            buf[(area.x + x, area.y + y)] = cell;
         }
 
         if scrollbar_needed {
@@ -265,7 +241,7 @@ impl SelectedTab {
     }
 
     const fn get_example_count(self) -> u16 {
-        #[allow(clippy::match_same_arms)]
+        #[expect(clippy::match_same_arms)]
         match self {
             Self::Length => 4,
             Self::Percentage => 5,
@@ -305,8 +281,8 @@ impl Widget for SelectedTab {
 
 impl SelectedTab {
     fn render_length_example(area: Rect, buf: &mut Buffer) {
-        let [example1, example2, example3, _] =
-            Layout::vertical([Length(EXAMPLE_HEIGHT); 4]).areas(area);
+        let layout = Layout::vertical([Length(EXAMPLE_HEIGHT); 4]);
+        let [example1, example2, example3, _] = area.layout(&layout);
 
         Example::new(&[Length(20), Length(20)]).render(example1, buf);
         Example::new(&[Length(20), Min(20)]).render(example2, buf);
@@ -314,8 +290,8 @@ impl SelectedTab {
     }
 
     fn render_percentage_example(area: Rect, buf: &mut Buffer) {
-        let [example1, example2, example3, example4, example5, _] =
-            Layout::vertical([Length(EXAMPLE_HEIGHT); 6]).areas(area);
+        let layout = Layout::vertical([Length(EXAMPLE_HEIGHT); 6]);
+        let [example1, example2, example3, example4, example5, _] = area.layout(&layout);
 
         Example::new(&[Percentage(75), Fill(0)]).render(example1, buf);
         Example::new(&[Percentage(25), Fill(0)]).render(example2, buf);
@@ -325,8 +301,8 @@ impl SelectedTab {
     }
 
     fn render_ratio_example(area: Rect, buf: &mut Buffer) {
-        let [example1, example2, example3, example4, _] =
-            Layout::vertical([Length(EXAMPLE_HEIGHT); 5]).areas(area);
+        let layout = Layout::vertical([Length(EXAMPLE_HEIGHT); 5]);
+        let [example1, example2, example3, example4, _] = area.layout(&layout);
 
         Example::new(&[Ratio(1, 2); 2]).render(example1, buf);
         Example::new(&[Ratio(1, 4); 4]).render(example2, buf);
@@ -335,15 +311,15 @@ impl SelectedTab {
     }
 
     fn render_fill_example(area: Rect, buf: &mut Buffer) {
-        let [example1, example2, _] = Layout::vertical([Length(EXAMPLE_HEIGHT); 3]).areas(area);
+        let [example1, example2, _] = area.layout(&Layout::vertical([Length(EXAMPLE_HEIGHT); 3]));
 
         Example::new(&[Fill(1), Fill(2), Fill(3)]).render(example1, buf);
         Example::new(&[Fill(1), Percentage(50), Fill(1)]).render(example2, buf);
     }
 
     fn render_min_example(area: Rect, buf: &mut Buffer) {
-        let [example1, example2, example3, example4, example5, _] =
-            Layout::vertical([Length(EXAMPLE_HEIGHT); 6]).areas(area);
+        let layout = Layout::vertical([Length(EXAMPLE_HEIGHT); 6]);
+        let [example1, example2, example3, example4, example5, _] = area.layout(&layout);
 
         Example::new(&[Percentage(100), Min(0)]).render(example1, buf);
         Example::new(&[Percentage(100), Min(20)]).render(example2, buf);
@@ -353,8 +329,8 @@ impl SelectedTab {
     }
 
     fn render_max_example(area: Rect, buf: &mut Buffer) {
-        let [example1, example2, example3, example4, example5, _] =
-            Layout::vertical([Length(EXAMPLE_HEIGHT); 6]).areas(area);
+        let layout = Layout::vertical([Length(EXAMPLE_HEIGHT); 6]);
+        let [example1, example2, example3, example4, example5, _] = area.layout(&layout);
 
         Example::new(&[Percentage(0), Max(0)]).render(example1, buf);
         Example::new(&[Percentage(0), Max(20)]).render(example2, buf);
@@ -378,9 +354,10 @@ impl Example {
 
 impl Widget for Example {
     fn render(self, area: Rect, buf: &mut Buffer) {
-        let [area, _] =
-            Layout::vertical([Length(ILLUSTRATION_HEIGHT), Length(SPACER_HEIGHT)]).areas(area);
-        let blocks = Layout::horizontal(&self.constraints).split(area);
+        let vertical = Layout::vertical([Length(ILLUSTRATION_HEIGHT), Length(SPACER_HEIGHT)]);
+        let horizontal = Layout::horizontal(&self.constraints);
+        let [area, _] = area.layout(&vertical);
+        let blocks = area.layout_vec(&horizontal);
 
         for (block, constraint) in blocks.iter().zip(&self.constraints) {
             Self::illustration(*constraint, block.width).render(*block, buf);
@@ -409,32 +386,3 @@ impl Example {
         Paragraph::new(text).centered().block(block)
     }
 }
-
-fn init_error_hooks() -> Result<()> {
-    let (panic, error) = HookBuilder::default().into_hooks();
-    let panic = panic.into_panic_hook();
-    let error = error.into_eyre_hook();
-    color_eyre::eyre::set_hook(Box::new(move |e| {
-        let _ = restore_terminal();
-        error(e)
-    }))?;
-    std::panic::set_hook(Box::new(move |info| {
-        let _ = restore_terminal();
-        panic(info);
-    }));
-    Ok(())
-}
-
-fn init_terminal() -> Result<Terminal<impl Backend>> {
-    enable_raw_mode()?;
-    stdout().execute(EnterAlternateScreen)?;
-    let backend = CrosstermBackend::new(stdout());
-    let terminal = Terminal::new(backend)?;
-    Ok(terminal)
-}
-
-fn restore_terminal() -> Result<()> {
-    disable_raw_mode()?;
-    stdout().execute(LeaveAlternateScreen)?;
-    Ok(())
-}

examples/apps/custom-widget/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "custom-widget"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm.workspace = true
+ratatui.workspace = true
+
+[lints]
+workspace = true

examples/apps/custom-widget/README.md

@@ -0,0 +1,9 @@
+# Custom widget demo
+
+This example shows how to create a custom widget that can be interacted with the mouse.
+
+To run this demo:
+
+```shell
+cargo run -p custom-widget
+```

examples/apps/custom-widget/src/main.rs

@@ -1,29 +1,37 @@
-//! # [Ratatui] Custom Widget example
-//!
-//! The latest version of this example is available in the [examples] folder in the repository.
-//!
-//! Please note that the examples are designed to be run against the `main` branch of the Github
-//! repository. This means that you may not be able to compile with the latest release version on
-//! crates.io, or the one that you have installed locally.
-//!
-//! See the [examples readme] for more information on finding examples that match the version of the
-//! library you are using.
-//!
-//! [Ratatui]: https://github.com/ratatui-org/ratatui
-//! [examples]: https://github.com/ratatui-org/ratatui/blob/main/examples
-//! [examples readme]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md
+/// A Ratatui example that demonstrates how to create a custom widget that can be interacted
+/// with using the mouse.
+///
+/// This example runs with the Ratatui library code in the branch that you are currently
+/// reading. See the [`latest`] branch for the code which works with the most recent Ratatui
+/// release.
+///
+/// [`latest`]: https://github.com/ratatui/ratatui/tree/latest
+use std::{io::stdout, ops::ControlFlow, time::Duration};
 
-use std::{error::Error, io, ops::ControlFlow, time::Duration};
-
-use crossterm::{
-    event::{
-        self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, MouseButton, MouseEvent,
-        MouseEventKind,
-    },
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+use color_eyre::Result;
+use crossterm::event::{
+    self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEvent, MouseButton,
+    MouseEvent, MouseEventKind,
 };
-use ratatui::{prelude::*, widgets::Paragraph};
+use crossterm::execute;
+use ratatui::buffer::Buffer;
+use ratatui::layout::{Constraint, Flex, Layout, Rect};
+use ratatui::style::{Color, Style};
+use ratatui::text::Line;
+use ratatui::widgets::{Paragraph, Widget};
+use ratatui::{DefaultTerminal, Frame};
+
+fn main() -> Result<()> {
+    color_eyre::install()?;
+    let terminal = ratatui::init();
+    execute!(stdout(), EnableMouseCapture)?;
+    let app_result = run(terminal);
+    ratatui::restore();
+    if let Err(err) = execute!(stdout(), DisableMouseCapture) {
+        eprintln!("Error disabling mouse capture: {err}");
+    }
+    app_result
+}
 
 /// A custom widget that renders a button with a label, theme and state.
 #[derive(Debug, Clone)]
@@ -90,8 +98,8 @@ impl<'a> Button<'a> {
     }
 }
 
-impl<'a> Widget for Button<'a> {
-    #[allow(clippy::cast_possible_truncation)]
+impl Widget for Button<'_> {
+    #[expect(clippy::cast_possible_truncation)]
     fn render(self, area: Rect, buf: &mut Buffer) {
         let (background, text, shadow, highlight) = self.colors();
         buf.set_style(area, Style::new().bg(background).fg(text));
@@ -135,46 +143,16 @@ impl Button<'_> {
     }
 }
 
-fn main() -> Result<(), Box<dyn Error>> {
-    // setup terminal
-    enable_raw_mode()?;
-    let mut stdout = io::stdout();
-    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
-    let backend = CrosstermBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
-
-    // create app and run it
-    let res = run_app(&mut terminal);
-
-    // restore terminal
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
-
-    if let Err(err) = res {
-        println!("{err:?}");
-    }
-
-    Ok(())
-}
-
-fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> io::Result<()> {
+fn run(mut terminal: DefaultTerminal) -> Result<()> {
     let mut selected_button: usize = 0;
     let mut button_states = [State::Selected, State::Normal, State::Normal];
     loop {
-        terminal.draw(|frame| ui(frame, button_states))?;
+        terminal.draw(|frame| render(frame, button_states))?;
         if !event::poll(Duration::from_millis(100))? {
             continue;
         }
         match event::read()? {
             Event::Key(key) => {
-                if key.kind != event::KeyEventKind::Press {
-                    continue;
-                }
                 if handle_key_event(key, &mut button_states, &mut selected_button).is_break() {
                     break;
                 }
@@ -188,14 +166,14 @@ fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> io::Result<()> {
     Ok(())
 }
 
-fn ui(frame: &mut Frame, states: [State; 3]) {
-    let vertical = Layout::vertical([
+fn render(frame: &mut Frame, states: [State; 3]) {
+    let layout = Layout::vertical([
         Constraint::Length(1),
         Constraint::Max(3),
         Constraint::Length(1),
         Constraint::Min(0), // ignore remaining space
     ]);
-    let [title, buttons, help, _] = vertical.areas(frame.size());
+    let [title, buttons, help, _] = frame.area().layout(&layout);
 
     frame.render_widget(
         Paragraph::new("Custom Widget Example (mouse enabled)"),
@@ -206,13 +184,8 @@ fn ui(frame: &mut Frame, states: [State; 3]) {
 }
 
 fn render_buttons(frame: &mut Frame<'_>, area: Rect, states: [State; 3]) {
-    let horizontal = Layout::horizontal([
-        Constraint::Length(15),
-        Constraint::Length(15),
-        Constraint::Length(15),
-        Constraint::Min(0), // ignore remaining space
-    ]);
-    let [red, green, blue, _] = horizontal.areas(area);
+    let layout = Layout::horizontal([Constraint::Length(15); 3]).flex(Flex::Start);
+    let [red, green, blue] = area.layout(&layout);
 
     frame.render_widget(Button::new("Red").theme(RED).state(states[0]), red);
     frame.render_widget(Button::new("Green").theme(GREEN).state(states[1]), green);
@@ -220,10 +193,13 @@ fn render_buttons(frame: &mut Frame<'_>, area: Rect, states: [State; 3]) {
 }
 
 fn handle_key_event(
-    key: event::KeyEvent,
+    key: KeyEvent,
     button_states: &mut [State; 3],
     selected_button: &mut usize,
 ) -> ControlFlow<()> {
+    if !key.is_press() {
+        return ControlFlow::Continue(());
+    }
     match key.code {
         KeyCode::Char('q') => return ControlFlow::Break(()),
         KeyCode::Left | KeyCode::Char('h') => {

examples/apps/demo/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "demo"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[features]
+default = ["crossterm"]
+crossterm = ["ratatui/crossterm", "dep:crossterm"]
+termion = ["ratatui/termion", "dep:termion"]
+termwiz = ["ratatui/termwiz", "dep:termwiz"]
+
+[dependencies]
+clap.workspace = true
+crossterm = { workspace = true, optional = true }
+rand.workspace = true
+ratatui.workspace = true
+termwiz = { workspace = true, optional = true }
+
+[target.'cfg(not(windows))'.dependencies]
+termion = { workspace = true, optional = true }

examples/apps/demo/README.md

@@ -0,0 +1,25 @@
+# Demo example
+
+This is the original demo that was developed for Tui-rs (the library that Ratatui was forked from).
+
+![demo.gif](https://github.com/ratatui/ratatui/blob/images/examples/demo.gif?raw=true)
+
+This example is available for each backend. To run it:
+
+## crossterm
+
+```shell
+cargo run -p demo
+```
+
+## termion
+
+```shell
+cargo run -p demo --no-default-features --features termion
+```
+
+## termwiz
+
+```shell
+cargo run -p demo --no-default-features --features termwiz
+```

examples/apps/demo/src/app.rs

@@ -1,7 +1,5 @@
-use rand::{
-    distributions::{Distribution, Uniform},
-    rngs::ThreadRng,
-};
+use rand::distr::{Distribution, Uniform};
+use rand::rngs::ThreadRng;
 use ratatui::widgets::ListState;
 
 const TASKS: [&str; 24] = [
@@ -75,8 +73,8 @@ pub struct RandomSignal {
 impl RandomSignal {
     pub fn new(lower: u64, upper: u64) -> Self {
         Self {
-            distribution: Uniform::new(lower, upper),
-            rng: rand::thread_rng(),
+            distribution: Uniform::new(lower, upper).expect("invalid range"),
+            rng: rand::rng(),
         }
     }
 }
@@ -122,8 +120,8 @@ pub struct TabsState<'a> {
 }
 
 impl<'a> TabsState<'a> {
-    pub fn new(titles: Vec<&'a str>) -> TabsState {
-        TabsState { titles, index: 0 }
+    pub const fn new(titles: Vec<&'a str>) -> Self {
+        Self { titles, index: 0 }
     }
     pub fn next(&mut self) {
         self.index = (self.index + 1) % self.titles.len();

examples/apps/demo/src/crossterm.rs

@@ -0,0 +1,76 @@
+use std::error::Error;
+use std::io;
+use std::time::{Duration, Instant};
+
+use crossterm::event::{self, DisableMouseCapture, EnableMouseCapture, KeyCode};
+use crossterm::execute;
+use crossterm::terminal::{
+    EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode,
+};
+use ratatui::Terminal;
+use ratatui::backend::{Backend, CrosstermBackend};
+
+use crate::app::App;
+use crate::ui;
+
+pub fn run(tick_rate: Duration, enhanced_graphics: bool) -> Result<(), Box<dyn Error>> {
+    // setup terminal
+    enable_raw_mode()?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    // create app and run it
+    let app = App::new("Crossterm Demo", enhanced_graphics);
+    let app_result = run_app(&mut terminal, app, tick_rate);
+
+    // restore terminal
+    disable_raw_mode()?;
+    execute!(
+        terminal.backend_mut(),
+        LeaveAlternateScreen,
+        DisableMouseCapture
+    )?;
+    terminal.show_cursor()?;
+
+    if let Err(err) = app_result {
+        println!("{err:?}");
+    }
+
+    Ok(())
+}
+
+fn run_app<B: Backend>(
+    terminal: &mut Terminal<B>,
+    mut app: App,
+    tick_rate: Duration,
+) -> Result<(), Box<dyn Error>>
+where
+    B::Error: 'static,
+{
+    let mut last_tick = Instant::now();
+    loop {
+        terminal.draw(|frame| ui::render(frame, &mut app))?;
+
+        let timeout = tick_rate.saturating_sub(last_tick.elapsed());
+        if !event::poll(timeout)? {
+            app.on_tick();
+            last_tick = Instant::now();
+            continue;
+        }
+        if let Some(key) = event::read()?.as_key_press_event() {
+            match key.code {
+                KeyCode::Char('h') | KeyCode::Left => app.on_left(),
+                KeyCode::Char('j') | KeyCode::Down => app.on_down(),
+                KeyCode::Char('k') | KeyCode::Up => app.on_up(),
+                KeyCode::Char('l') | KeyCode::Right => app.on_right(),
+                KeyCode::Char(c) => app.on_key(c),
+                _ => {}
+            }
+        }
+        if app.should_quit {
+            return Ok(());
+        }
+    }
+}

examples/apps/demo/src/main.rs

@@ -9,18 +9,19 @@
 //! See the [examples readme] for more information on finding examples that match the version of the
 //! library you are using.
 //!
-//! [Ratatui]: https://github.com/ratatui-org/ratatui
-//! [examples]: https://github.com/ratatui-org/ratatui/blob/main/examples
-//! [examples readme]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md
+//! [Ratatui]: https://github.com/ratatui/ratatui
+//! [examples]: https://github.com/ratatui/ratatui/blob/main/examples
+//! [examples readme]: https://github.com/ratatui/ratatui/blob/main/examples/README.md
 
-use std::{error::Error, time::Duration};
+use std::error::Error;
+use std::time::Duration;
 
-use argh::FromArgs;
+use clap::Parser;
 
 mod app;
 #[cfg(feature = "crossterm")]
 mod crossterm;
-#[cfg(feature = "termion")]
+#[cfg(all(not(windows), feature = "termion"))]
 mod termion;
 #[cfg(feature = "termwiz")]
 mod termwiz;
@@ -28,24 +29,29 @@ mod termwiz;
 mod ui;
 
 /// Demo
-#[derive(Debug, FromArgs)]
+#[derive(Debug, Parser)]
 struct Cli {
     /// time in ms between two ticks.
-    #[argh(option, default = "250")]
+    #[arg(short, long, default_value_t = 250)]
     tick_rate: u64,
+
     /// whether unicode symbols are used to improve the overall look of the app
-    #[argh(option, default = "true")]
-    enhanced_graphics: bool,
+    #[arg(short, long, default_value_t = true)]
+    unicode: bool,
 }
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let cli: Cli = argh::from_env();
+    let cli = Cli::parse();
     let tick_rate = Duration::from_millis(cli.tick_rate);
     #[cfg(feature = "crossterm")]
-    crate::crossterm::run(tick_rate, cli.enhanced_graphics)?;
-    #[cfg(feature = "termion")]
-    crate::termion::run(tick_rate, cli.enhanced_graphics)?;
-    #[cfg(feature = "termwiz")]
-    crate::termwiz::run(tick_rate, cli.enhanced_graphics)?;
+    crate::crossterm::run(tick_rate, cli.unicode)?;
+    #[cfg(all(not(windows), feature = "termion", not(feature = "crossterm")))]
+    crate::termion::run(tick_rate, cli.unicode)?;
+    #[cfg(all(
+        feature = "termwiz",
+        not(feature = "crossterm"),
+        not(feature = "termion")
+    ))]
+    crate::termwiz::run(tick_rate, cli.unicode)?;
     Ok(())
 }

examples/apps/demo/src/termion.rs

@@ -1,14 +1,18 @@
-use std::{error::Error, io, sync::mpsc, thread, time::Duration};
+#![allow(dead_code)]
+use std::error::Error;
+use std::sync::mpsc;
+use std::time::Duration;
+use std::{io, thread};
 
-use ratatui::prelude::*;
-use termion::{
-    event::Key,
-    input::{MouseTerminal, TermRead},
-    raw::IntoRawMode,
-    screen::IntoAlternateScreen,
-};
+use ratatui::Terminal;
+use ratatui::backend::{Backend, TermionBackend};
+use termion::event::Key;
+use termion::input::{MouseTerminal, TermRead};
+use termion::raw::IntoRawMode;
+use termion::screen::IntoAlternateScreen;
 
-use crate::{app::App, ui};
+use crate::app::App;
+use crate::ui;
 
 pub fn run(tick_rate: Duration, enhanced_graphics: bool) -> Result<(), Box<dyn Error>> {
     // setup terminal
@@ -32,10 +36,13 @@ fn run_app<B: Backend>(
     terminal: &mut Terminal<B>,
     mut app: App,
     tick_rate: Duration,
-) -> Result<(), Box<dyn Error>> {
+) -> Result<(), Box<dyn Error>>
+where
+    B::Error: 'static,
+{
     let events = events(tick_rate);
     loop {
-        terminal.draw(|f| ui::draw(f, &mut app))?;
+        terminal.draw(|frame| ui::render(frame, &mut app))?;
 
         match events.recv()? {
             Event::Input(key) => match key {
@@ -71,12 +78,14 @@ fn events(tick_rate: Duration) -> mpsc::Receiver<Event> {
             }
         }
     });
-    thread::spawn(move || loop {
-        if let Err(err) = tx.send(Event::Tick) {
-            eprintln!("{err}");
-            break;
+    thread::spawn(move || {
+        loop {
+            if let Err(err) = tx.send(Event::Tick) {
+                eprintln!("{err}");
+                break;
+            }
+            thread::sleep(tick_rate);
         }
-        thread::sleep(tick_rate);
     });
     rx
 }

examples/apps/demo/src/termwiz.rs

@@ -1,15 +1,14 @@
-use std::{
-    error::Error,
-    time::{Duration, Instant},
-};
+#![allow(dead_code)]
+use std::error::Error;
+use std::time::{Duration, Instant};
 
-use ratatui::prelude::*;
-use termwiz::{
-    input::{InputEvent, KeyCode},
-    terminal::Terminal as TermwizTerminal,
-};
+use ratatui::Terminal;
+use ratatui::backend::TermwizBackend;
+use termwiz::input::{InputEvent, KeyCode};
+use termwiz::terminal::Terminal as TermwizTerminal;
 
-use crate::{app::App, ui};
+use crate::app::App;
+use crate::ui;
 
 pub fn run(tick_rate: Duration, enhanced_graphics: bool) -> Result<(), Box<dyn Error>> {
     let backend = TermwizBackend::new()?;
@@ -18,12 +17,12 @@ pub fn run(tick_rate: Duration, enhanced_graphics: bool) -> Result<(), Box<dyn E
 
     // create app and run it
     let app = App::new("Termwiz Demo", enhanced_graphics);
-    let res = run_app(&mut terminal, app, tick_rate);
+    let app_result = run_app(&mut terminal, app, tick_rate);
 
     terminal.show_cursor()?;
     terminal.flush()?;
 
-    if let Err(err) = res {
+    if let Err(err) = app_result {
         println!("{err:?}");
     }
 
@@ -37,7 +36,7 @@ fn run_app(
 ) -> Result<(), Box<dyn Error>> {
     let mut last_tick = Instant::now();
     loop {
-        terminal.draw(|f| ui::draw(f, &mut app))?;
+        terminal.draw(|frame| ui::render(frame, &mut app))?;
 
         let timeout = tick_rate.saturating_sub(last_tick.elapsed());
         if let Some(input) = terminal

examples/apps/demo/src/ui.rs

@@ -1,13 +1,17 @@
-#[allow(clippy::wildcard_imports)]
-use ratatui::{
-    prelude::*,
-    widgets::{canvas::*, *},
+use ratatui::layout::{Constraint, Layout, Rect};
+use ratatui::style::{Color, Modifier, Style};
+use ratatui::text::{self, Span};
+use ratatui::widgets::canvas::{self, Canvas, Circle, Map, MapResolution, Rectangle};
+use ratatui::widgets::{
+    Axis, BarChart, Block, Cell, Chart, Dataset, Gauge, LineGauge, List, ListItem, Paragraph, Row,
+    Sparkline, Table, Tabs, Wrap,
 };
+use ratatui::{Frame, symbols};
 
 use crate::app::App;
 
-pub fn draw(f: &mut Frame, app: &mut App) {
-    let chunks = Layout::vertical([Constraint::Length(3), Constraint::Min(0)]).split(f.size());
+pub fn render(frame: &mut Frame, app: &mut App) {
+    let chunks = Layout::vertical([Constraint::Length(3), Constraint::Min(0)]).split(frame.area());
     let tabs = app
         .tabs
         .titles
@@ -17,37 +21,37 @@ pub fn draw(f: &mut Frame, app: &mut App) {
         .block(Block::bordered().title(app.title))
         .highlight_style(Style::default().fg(Color::Yellow))
         .select(app.tabs.index);
-    f.render_widget(tabs, chunks[0]);
+    frame.render_widget(tabs, chunks[0]);
     match app.tabs.index {
-        0 => draw_first_tab(f, app, chunks[1]),
-        1 => draw_second_tab(f, app, chunks[1]),
-        2 => draw_third_tab(f, app, chunks[1]),
+        0 => draw_first_tab(frame, app, chunks[1]),
+        1 => draw_second_tab(frame, app, chunks[1]),
+        2 => draw_third_tab(frame, app, chunks[1]),
         _ => {}
     };
 }
 
-fn draw_first_tab(f: &mut Frame, app: &mut App, area: Rect) {
+fn draw_first_tab(frame: &mut Frame, app: &mut App, area: Rect) {
     let chunks = Layout::vertical([
         Constraint::Length(9),
         Constraint::Min(8),
         Constraint::Length(7),
     ])
     .split(area);
-    draw_gauges(f, app, chunks[0]);
-    draw_charts(f, app, chunks[1]);
-    draw_text(f, chunks[2]);
+    draw_gauges(frame, app, chunks[0]);
+    draw_charts(frame, app, chunks[1]);
+    draw_text(frame, chunks[2]);
 }
 
-fn draw_gauges(f: &mut Frame, app: &mut App, area: Rect) {
+fn draw_gauges(frame: &mut Frame, app: &mut App, area: Rect) {
     let chunks = Layout::vertical([
         Constraint::Length(2),
         Constraint::Length(3),
-        Constraint::Length(1),
+        Constraint::Length(2),
     ])
     .margin(1)
     .split(area);
     let block = Block::bordered().title("Graphs");
-    f.render_widget(block, area);
+    frame.render_widget(block, area);
 
     let label = format!("{:.2}%", app.progress * 100.0);
     let gauge = Gauge::default()
@@ -61,7 +65,7 @@ fn draw_gauges(f: &mut Frame, app: &mut App, area: Rect) {
         .use_unicode(app.enhanced_graphics)
         .label(label)
         .ratio(app.progress);
-    f.render_widget(gauge, chunks[0]);
+    frame.render_widget(gauge, chunks[0]);
 
     let sparkline = Sparkline::default()
         .block(Block::new().title("Sparkline:"))
@@ -72,22 +76,27 @@ fn draw_gauges(f: &mut Frame, app: &mut App, area: Rect) {
         } else {
             symbols::bar::THREE_LEVELS
         });
-    f.render_widget(sparkline, chunks[1]);
+    frame.render_widget(sparkline, chunks[1]);
 
     let line_gauge = LineGauge::default()
         .block(Block::new().title("LineGauge:"))
-        .gauge_style(Style::default().fg(Color::Magenta))
-        .line_set(if app.enhanced_graphics {
-            symbols::line::THICK
+        .filled_style(Style::default().fg(Color::Magenta))
+        .filled_symbol(if app.enhanced_graphics {
+            symbols::line::THICK_HORIZONTAL
         } else {
-            symbols::line::NORMAL
+            symbols::line::HORIZONTAL
+        })
+        .unfilled_symbol(if app.enhanced_graphics {
+            symbols::line::THICK_HORIZONTAL
+        } else {
+            symbols::line::HORIZONTAL
         })
         .ratio(app.progress);
-    f.render_widget(line_gauge, chunks[2]);
+    frame.render_widget(line_gauge, chunks[2]);
 }
 
-#[allow(clippy::too_many_lines)]
-fn draw_charts(f: &mut Frame, app: &mut App, area: Rect) {
+#[expect(clippy::too_many_lines)]
+fn draw_charts(frame: &mut Frame, app: &mut App, area: Rect) {
     let constraints = if app.show_chart {
         vec![Constraint::Percentage(50), Constraint::Percentage(50)]
     } else {
@@ -113,7 +122,7 @@ fn draw_charts(f: &mut Frame, app: &mut App, area: Rect) {
                 .block(Block::bordered().title("List"))
                 .highlight_style(Style::default().add_modifier(Modifier::BOLD))
                 .highlight_symbol("> ");
-            f.render_stateful_widget(tasks, chunks[0], &mut app.tasks.state);
+            frame.render_stateful_widget(tasks, chunks[0], &mut app.tasks.state);
 
             // Draw logs
             let info_style = Style::default().fg(Color::Blue);
@@ -139,7 +148,7 @@ fn draw_charts(f: &mut Frame, app: &mut App, area: Rect) {
                 })
                 .collect();
             let logs = List::new(logs).block(Block::bordered().title("List"));
-            f.render_stateful_widget(logs, chunks[1], &mut app.logs.state);
+            frame.render_stateful_widget(logs, chunks[1], &mut app.logs.state);
         }
 
         let barchart = BarChart::default()
@@ -160,7 +169,7 @@ fn draw_charts(f: &mut Frame, app: &mut App, area: Rect) {
             )
             .label_style(Style::default().fg(Color::Yellow))
             .bar_style(Style::default().fg(Color::Green));
-        f.render_widget(barchart, chunks[1]);
+        frame.render_widget(barchart, chunks[1]);
     }
     if app.show_chart {
         let x_labels = vec![
@@ -214,19 +223,21 @@ fn draw_charts(f: &mut Frame, app: &mut App, area: Rect) {
                     .title("Y Axis")
                     .style(Style::default().fg(Color::Gray))
                     .bounds([-20.0, 20.0])
-                    .labels(vec![
+                    .labels([
                         Span::styled("-20", Style::default().add_modifier(Modifier::BOLD)),
                         Span::raw("0"),
                         Span::styled("20", Style::default().add_modifier(Modifier::BOLD)),
                     ]),
             );
-        f.render_widget(chart, chunks[1]);
+        frame.render_widget(chart, chunks[1]);
     }
 }
 
-fn draw_text(f: &mut Frame, area: Rect) {
+fn draw_text(frame: &mut Frame, area: Rect) {
     let text = vec![
-        text::Line::from("This is a paragraph with several lines. You can change style your text the way you want"),
+        text::Line::from(
+            "This is a paragraph with several lines. You can change style your text the way you want",
+        ),
         text::Line::from(""),
         text::Line::from(vec![
             Span::from("For example: "),
@@ -241,16 +252,17 @@ fn draw_text(f: &mut Frame, area: Rect) {
             Span::raw("Oh and if you didn't "),
             Span::styled("notice", Style::default().add_modifier(Modifier::ITALIC)),
             Span::raw(" you can "),
-            Span::styled("automatically", Style::default().add_modifier(Modifier::BOLD)),
+            Span::styled(
+                "automatically",
+                Style::default().add_modifier(Modifier::BOLD),
+            ),
             Span::raw(" "),
             Span::styled("wrap", Style::default().add_modifier(Modifier::REVERSED)),
             Span::raw(" your "),
             Span::styled("text", Style::default().add_modifier(Modifier::UNDERLINED)),
-            Span::raw(".")
+            Span::raw("."),
         ]),
-        text::Line::from(
-            "One more thing is that it should display unicode characters: 10€"
-        ),
+        text::Line::from("One more thing is that it should display unicode characters: 10€"),
     ];
     let block = Block::bordered().title(Span::styled(
         "Footer",
@@ -259,10 +271,10 @@ fn draw_text(f: &mut Frame, area: Rect) {
             .add_modifier(Modifier::BOLD),
     ));
     let paragraph = Paragraph::new(text).block(block).wrap(Wrap { trim: true });
-    f.render_widget(paragraph, area);
+    frame.render_widget(paragraph, area);
 }
 
-fn draw_second_tab(f: &mut Frame, app: &mut App, area: Rect) {
+fn draw_second_tab(frame: &mut Frame, app: &mut App, area: Rect) {
     let chunks =
         Layout::horizontal([Constraint::Percentage(30), Constraint::Percentage(70)]).split(area);
     let up_style = Style::default().fg(Color::Green);
@@ -291,7 +303,7 @@ fn draw_second_tab(f: &mut Frame, app: &mut App, area: Rect) {
             .bottom_margin(1),
     )
     .block(Block::bordered().title("Servers"));
-    f.render_widget(table, chunks[0]);
+    frame.render_widget(table, chunks[0]);
 
     let map = Canvas::default()
         .block(Block::bordered().title("World"))
@@ -345,10 +357,10 @@ fn draw_second_tab(f: &mut Frame, app: &mut App, area: Rect) {
         })
         .x_bounds([-180.0, 180.0])
         .y_bounds([-90.0, 90.0]);
-    f.render_widget(map, chunks[1]);
+    frame.render_widget(map, chunks[1]);
 }
 
-fn draw_third_tab(f: &mut Frame, _app: &mut App, area: Rect) {
+fn draw_third_tab(frame: &mut Frame, _app: &mut App, area: Rect) {
     let chunks = Layout::horizontal([Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)]).split(area);
     let colors = [
         Color::Reset,
@@ -389,5 +401,5 @@ fn draw_third_tab(f: &mut Frame, _app: &mut App, area: Rect) {
         ],
     )
     .block(Block::bordered().title("Colors"));
-    f.render_widget(table, chunks[0]);
+    frame.render_widget(table, chunks[0]);
 }

examples/apps/demo2/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "demo2"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm.workspace = true
+indoc.workspace = true
+itertools.workspace = true
+palette.workspace = true
+rand.workspace = true
+rand_chacha.workspace = true
+ratatui = { workspace = true, features = ["all-widgets"] }
+strum.workspace = true
+time.workspace = true
+unicode-width.workspace = true

examples/apps/demo2/README.md

@@ -0,0 +1,9 @@
+## Demo2
+
+This is the demo example from the main README and crate page. Source: [demo2](./demo2/).
+
+```shell
+cargo run -p demo2
+```
+
+![Demo2](https://github.com/ratatui/ratatui/blob/images/examples/demo2.gif?raw=true)

examples/apps/demo2/src/app.rs

@@ -1,12 +1,19 @@
 use std::time::Duration;
 
-use color_eyre::{eyre::Context, Result};
-use crossterm::event::{Event, KeyCode, KeyEvent, KeyEventKind};
+use color_eyre::Result;
+use color_eyre::eyre::Context;
+use crossterm::event::{self, KeyCode};
 use itertools::Itertools;
-use ratatui::{prelude::*, widgets::*};
+use ratatui::buffer::Buffer;
+use ratatui::layout::{Constraint, Layout, Rect};
+use ratatui::style::Color;
+use ratatui::text::{Line, Span};
+use ratatui::widgets::{Block, Tabs, Widget};
+use ratatui::{DefaultTerminal, Frame};
 use strum::{Display, EnumIter, FromRepr, IntoEnumIterator};
 
-use crate::{destroy, tabs::*, term, THEME};
+use crate::tabs::{AboutTab, EmailTab, RecipeTab, TracerouteTab, WeatherTab};
+use crate::{THEME, destroy};
 
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
 pub struct App {
@@ -37,15 +44,13 @@ enum Tab {
     Weather,
 }
 
-pub fn run(terminal: &mut Terminal<impl Backend>) -> Result<()> {
-    App::default().run(terminal)
-}
-
 impl App {
     /// Run the app until the user quits.
-    pub fn run(&mut self, terminal: &mut Terminal<impl Backend>) -> Result<()> {
+    pub fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
         while self.is_running() {
-            self.draw(terminal)?;
+            terminal
+                .draw(|frame| self.render(frame))
+                .wrap_err("terminal.draw")?;
             self.handle_events()?;
         }
         Ok(())
@@ -55,17 +60,12 @@ impl App {
         self.mode != Mode::Quit
     }
 
-    /// Draw a single frame of the app.
-    fn draw(&self, terminal: &mut Terminal<impl Backend>) -> Result<()> {
-        terminal
-            .draw(|frame| {
-                frame.render_widget(self, frame.size());
-                if self.mode == Mode::Destroy {
-                    destroy::destroy(frame);
-                }
-            })
-            .wrap_err("terminal.draw")?;
-        Ok(())
+    /// Render a single frame of the app.
+    fn render(&self, frame: &mut Frame) {
+        frame.render_widget(self, frame.area());
+        if self.mode == Mode::Destroy {
+            destroy::destroy(frame);
+        }
     }
 
     /// Handle events from the terminal.
@@ -74,26 +74,23 @@ impl App {
     /// 1/50th of a second. This was chosen to try to match the default frame rate of a GIF in VHS.
     fn handle_events(&mut self) -> Result<()> {
         let timeout = Duration::from_secs_f64(1.0 / 50.0);
-        match term::next_event(timeout)? {
-            Some(Event::Key(key)) if key.kind == KeyEventKind::Press => self.handle_key_press(key),
-            _ => {}
+        if !event::poll(timeout)? {
+            return Ok(());
+        }
+        if let Some(key) = event::read()?.as_key_press_event() {
+            match key.code {
+                KeyCode::Char('q') | KeyCode::Esc => self.mode = Mode::Quit,
+                KeyCode::Char('h') | KeyCode::Left => self.prev_tab(),
+                KeyCode::Char('l') | KeyCode::Right | KeyCode::Tab => self.next_tab(),
+                KeyCode::Char('k') | KeyCode::Up => self.prev(),
+                KeyCode::Char('j') | KeyCode::Down => self.next(),
+                KeyCode::Char('d') | KeyCode::Delete => self.destroy(),
+                _ => {}
+            };
         }
         Ok(())
     }
 
-    fn handle_key_press(&mut self, key: KeyEvent) {
-        use KeyCode::*;
-        match key.code {
-            Char('q') | Esc => self.mode = Mode::Quit,
-            Char('h') | Left => self.prev_tab(),
-            Char('l') | Right => self.next_tab(),
-            Char('k') | Up => self.prev(),
-            Char('j') | Down => self.next(),
-            Char('d') | Delete => self.destroy(),
-            _ => {}
-        };
-    }
-
     fn prev(&mut self) {
         match self.tab {
             Tab::About => self.about_tab.prev_row(),
@@ -132,12 +129,12 @@ impl App {
 /// matter, but for larger apps this can be a significant performance improvement.
 impl Widget for &App {
     fn render(self, area: Rect, buf: &mut Buffer) {
-        let vertical = Layout::vertical([
+        let layout = Layout::vertical([
             Constraint::Length(1),
             Constraint::Min(0),
             Constraint::Length(1),
         ]);
-        let [title_bar, tab, bottom_bar] = vertical.areas(area);
+        let [title_bar, tab, bottom_bar] = area.layout(&layout);
 
         Block::new().style(THEME.root).render(area, buf);
         self.render_title_bar(title_bar, buf);
@@ -149,7 +146,7 @@ impl Widget for &App {
 impl App {
     fn render_title_bar(&self, area: Rect, buf: &mut Buffer) {
         let layout = Layout::horizontal([Constraint::Min(0), Constraint::Length(43)]);
-        let [title, tabs] = layout.areas(area);
+        let [title, tabs] = area.layout(&layout);
 
         Span::styled("Ratatui", THEME.app_title).render(title, buf);
         let titles = Tab::iter().map(Tab::title);

examples/apps/demo2/src/colors.rs

@@ -1,5 +1,8 @@
 use palette::{IntoColor, Okhsv, Srgb};
-use ratatui::prelude::*;
+use ratatui::buffer::Buffer;
+use ratatui::layout::Rect;
+use ratatui::style::Color;
+use ratatui::widgets::Widget;
 
 /// A widget that renders a color swatch of RGB colors.
 ///
@@ -9,7 +12,7 @@ use ratatui::prelude::*;
 pub struct RgbSwatch;
 
 impl Widget for RgbSwatch {
-    #[allow(clippy::cast_precision_loss, clippy::similar_names)]
+    #[expect(clippy::cast_precision_loss, clippy::similar_names)]
     fn render(self, area: Rect, buf: &mut Buffer) {
         for (yi, y) in (area.top()..area.bottom()).enumerate() {
             let value = f32::from(area.height) - yi as f32;
@@ -19,7 +22,7 @@ impl Widget for RgbSwatch {
                 let hue = xi as f32 * 360.0 / f32::from(area.width);
                 let fg = color_from_oklab(hue, Okhsv::max_saturation(), value_fg);
                 let bg = color_from_oklab(hue, Okhsv::max_saturation(), value_bg);
-                buf.get_mut(x, y).set_char('▀').set_fg(fg).set_bg(bg);
+                buf[(x, y)].set_char('▀').set_fg(fg).set_bg(bg);
             }
         }
     }

examples/apps/demo2/src/destroy.rs

@@ -1,16 +1,18 @@
 use rand::Rng;
 use rand_chacha::rand_core::SeedableRng;
-use ratatui::{buffer::Cell, layout::Flex, prelude::*};
-use unicode_width::UnicodeWidthStr;
-
-use crate::big_text::{BigTextBuilder, PixelSize};
+use ratatui::Frame;
+use ratatui::buffer::Buffer;
+use ratatui::layout::{Flex, Layout, Rect};
+use ratatui::style::{Color, Style};
+use ratatui::text::Text;
+use ratatui::widgets::Widget;
 
 /// delay the start of the animation so it doesn't start immediately
-const DELAY: usize = 240;
+const DELAY: usize = 120;
 /// higher means more pixels per frame are modified in the animation
-const DRIP_SPEED: usize = 50;
+const DRIP_SPEED: usize = 500;
 /// delay the start of the text animation so it doesn't start immediately after the initial delay
-const TEXT_DELAY: usize = 240;
+const TEXT_DELAY: usize = 180;
 
 /// Destroy mode activated by pressing `d`
 pub fn destroy(frame: &mut Frame<'_>) {
@@ -19,7 +21,7 @@ pub fn destroy(frame: &mut Frame<'_>) {
         return;
     }
 
-    let area = frame.size();
+    let area = frame.area();
     let buf = frame.buffer_mut();
 
     drip(frame_count, area, buf);
@@ -30,7 +32,7 @@ pub fn destroy(frame: &mut Frame<'_>) {
 ///
 /// Each pick some random pixels and move them each down one row. This is a very inefficient way to
 /// do this, but it works well enough for this demo.
-#[allow(
+#[expect(
     clippy::cast_possible_truncation,
     clippy::cast_precision_loss,
     clippy::cast_sign_loss
@@ -43,63 +45,61 @@ fn drip(frame_count: usize, area: Rect, buf: &mut Buffer) {
     let variable_speed = DRIP_SPEED as f64 * fractional_speed * fractional_speed * fractional_speed;
     let pixel_count = (frame_count as f64 * variable_speed).floor() as usize;
     for _ in 0..pixel_count {
-        let src_x = rng.gen_range(0..area.width);
-        let src_y = rng.gen_range(1..area.height - 2);
-        let src = buf.get_mut(src_x, src_y).clone();
+        let src_x = rng.random_range(0..area.width);
+        let src_y = rng.random_range(1..area.height - 2);
+        let src = buf[(src_x, src_y)].clone();
         // 1% of the time, move a blank or pixel (10:1) to the top line of the screen
-        if rng.gen_ratio(1, 100) {
+        if rng.random_ratio(1, 100) {
             let dest_x = rng
-                .gen_range(src_x.saturating_sub(5)..src_x.saturating_add(5))
+                .random_range(src_x.saturating_sub(5)..src_x.saturating_add(5))
                 .clamp(area.left(), area.right() - 1);
             let dest_y = area.top() + 1;
 
-            let dest = buf.get_mut(dest_x, dest_y);
+            let dest = &mut buf[(dest_x, dest_y)];
             // copy the cell to the new location about 1/10 of the time blank out the cell the rest
             // of the time. This has the effect of gradually removing the pixels from the screen.
-            if rng.gen_ratio(1, 10) {
+            if rng.random_ratio(1, 10) {
                 *dest = src;
             } else {
-                *dest = Cell::default();
+                dest.reset();
             }
         } else {
             // move the pixel down one row
             let dest_x = src_x;
             let dest_y = src_y.saturating_add(1).min(area.bottom() - 2);
             // copy the cell to the new location
-            let dest = buf.get_mut(dest_x, dest_y);
-            *dest = src;
+            buf[(dest_x, dest_y)] = src;
         }
     }
 }
 
 /// draw some text fading in and out from black to red and back
-#[allow(clippy::cast_possible_truncation, clippy::cast_precision_loss)]
+#[expect(clippy::cast_possible_truncation, clippy::cast_precision_loss)]
 fn text(frame_count: usize, area: Rect, buf: &mut Buffer) {
     let sub_frame = frame_count.saturating_sub(TEXT_DELAY);
     if sub_frame == 0 {
         return;
     }
 
-    let line = "RATATUI";
-    let big_text = BigTextBuilder::default()
-        .lines([line.into()])
-        .pixel_size(PixelSize::Full)
-        .style(Style::new().fg(Color::Rgb(255, 0, 0)))
-        .build()
-        .unwrap();
-
-    // the font size is 8x8 for each character and we have 1 line
-    let area = centered_rect(area, line.width() as u16 * 8, 8);
+    let logo = indoc::indoc! {"
+        ██████      ████    ██████    ████    ██████  ██    ██  ██
+        ██    ██  ██    ██    ██    ██    ██    ██    ██    ██  ██
+        ██████    ████████    ██    ████████    ██    ██    ██  ██
+        ██  ██    ██    ██    ██    ██    ██    ██    ██    ██  ██
+        ██    ██  ██    ██    ██    ██    ██    ██      ████    ██
+    "};
+    let logo_text = Text::styled(logo, Color::Rgb(255, 255, 255));
+    let area = centered_rect(area, logo_text.width() as u16, logo_text.height() as u16);
 
     let mask_buf = &mut Buffer::empty(area);
-    big_text.render(area, mask_buf);
+    logo_text.render(area, mask_buf);
 
     let percentage = (sub_frame as f64 / 480.0).clamp(0.0, 1.0);
 
     for row in area.rows() {
         for col in row.columns() {
-            let cell = buf.get_mut(col.x, col.y);
-            let mask_cell = mask_buf.get(col.x, col.y);
+            let cell = &mut buf[(col.x, col.y)];
+            let mask_cell = &mut mask_buf[(col.x, col.y)];
             cell.set_symbol(mask_cell.symbol());
 
             // blend the mask cell color with the cell color
@@ -126,7 +126,7 @@ fn blend(mask_color: Color, cell_color: Color, percentage: f64) -> Color {
     let green = f64::from(mask_green).mul_add(percentage, f64::from(cell_green) * remain);
     let blue = f64::from(mask_blue).mul_add(percentage, f64::from(cell_blue) * remain);
 
-    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+    #[expect(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
     Color::Rgb(red as u8, green as u8, blue as u8)
 }
 
@@ -134,7 +134,7 @@ fn blend(mask_color: Color, cell_color: Color, percentage: f64) -> Color {
 fn centered_rect(area: Rect, width: u16, height: u16) -> Rect {
     let horizontal = Layout::horizontal([width]).flex(Flex::Center);
     let vertical = Layout::vertical([height]).flex(Flex::Center);
-    let [area] = vertical.areas(area);
-    let [area] = horizontal.areas(area);
+    let [area] = area.layout(&vertical);
+    let [area] = area.layout(&horizontal);
     area
 }

examples/apps/demo2/src/main.rs

@@ -0,0 +1,51 @@
+//! # [Ratatui] Demo2 example
+//!
+//! The latest version of this example is available in the [examples] folder in the repository.
+//!
+//! Please note that the examples are designed to be run against the `main` branch of the Github
+//! repository. This means that you may not be able to compile with the latest release version on
+//! crates.io, or the one that you have installed locally.
+//!
+//! See the [examples readme] for more information on finding examples that match the version of the
+//! library you are using.
+//!
+//! [Ratatui]: https://github.com/ratatui/ratatui
+//! [examples]: https://github.com/ratatui/ratatui/blob/main/examples
+//! [examples readme]: https://github.com/ratatui/ratatui/blob/main/examples/README.md
+
+#![allow(
+    clippy::missing_errors_doc,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate
+)]
+
+mod app;
+mod colors;
+mod destroy;
+mod tabs;
+mod theme;
+
+use std::io::stdout;
+
+use app::App;
+use color_eyre::Result;
+use crossterm::execute;
+use crossterm::terminal::{EnterAlternateScreen, LeaveAlternateScreen};
+use ratatui::layout::Rect;
+use ratatui::{TerminalOptions, Viewport};
+
+pub use self::colors::{RgbSwatch, color_from_oklab};
+pub use self::theme::THEME;
+
+fn main() -> Result<()> {
+    color_eyre::install()?;
+    // this size is to match the size of the terminal when running the demo
+    // using vhs in a 1280x640 sized window (github social preview size)
+    let viewport = Viewport::Fixed(Rect::new(0, 0, 81, 18));
+    let terminal = ratatui::init_with_options(TerminalOptions { viewport });
+    execute!(stdout(), EnterAlternateScreen).expect("failed to enter alternate screen");
+    let app_result = App::default().run(terminal);
+    execute!(stdout(), LeaveAlternateScreen).expect("failed to leave alternate screen");
+    ratatui::restore();
+    app_result
+}

examples/apps/demo2/src/tabs/about.rs

@@ -0,0 +1,73 @@
+use ratatui::buffer::Buffer;
+use ratatui::layout::{Alignment, Constraint, Layout, Margin, Rect};
+use ratatui::widgets::{
+    Block, Borders, Clear, MascotEyeColor, Padding, Paragraph, RatatuiMascot, Widget, Wrap,
+};
+
+use crate::{RgbSwatch, THEME};
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct AboutTab {
+    row_index: usize,
+}
+
+impl AboutTab {
+    pub fn prev_row(&mut self) {
+        self.row_index = self.row_index.saturating_sub(1);
+    }
+
+    pub fn next_row(&mut self) {
+        self.row_index = self.row_index.saturating_add(1);
+    }
+}
+
+impl Widget for AboutTab {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        RgbSwatch.render(area, buf);
+        let layout = Layout::horizontal([Constraint::Length(34), Constraint::Min(0)]);
+        let [logo_area, description] = area.layout(&layout);
+        render_crate_description(description, buf);
+        let eye_state = if self.row_index % 2 == 0 {
+            MascotEyeColor::Default
+        } else {
+            MascotEyeColor::Red
+        };
+        RatatuiMascot::default().set_eye(eye_state).render(
+            logo_area.inner(Margin {
+                vertical: 0,
+                horizontal: 2,
+            }),
+            buf,
+        );
+    }
+}
+
+fn render_crate_description(area: Rect, buf: &mut Buffer) {
+    let area = area.inner(Margin {
+        vertical: 4,
+        horizontal: 2,
+    });
+    Clear.render(area, buf); // clear out the color swatches
+    Block::new().style(THEME.content).render(area, buf);
+    let area = area.inner(Margin {
+        vertical: 1,
+        horizontal: 2,
+    });
+    let text = "- cooking up terminal user interfaces -
+
+    Ratatui is a Rust crate that provides widgets (e.g. Paragraph, Table) and draws them to the \
+    screen efficiently every frame.";
+    Paragraph::new(text)
+        .style(THEME.description)
+        .block(
+            Block::new()
+                .title(" Ratatui ")
+                .title_alignment(Alignment::Center)
+                .borders(Borders::TOP)
+                .border_style(THEME.description_title)
+                .padding(Padding::new(0, 0, 0, 0)),
+        )
+        .wrap(Wrap { trim: true })
+        .scroll((0, 0))
+        .render(area, buf);
+}

examples/apps/demo2/src/tabs/email.rs

@@ -1,5 +1,12 @@
 use itertools::Itertools;
-use ratatui::{prelude::*, widgets::*};
+use ratatui::buffer::Buffer;
+use ratatui::layout::{Constraint, Layout, Margin, Rect};
+use ratatui::style::{Styled, Stylize};
+use ratatui::text::Line;
+use ratatui::widgets::{
+    Block, BorderType, Borders, Clear, List, ListItem, ListState, Padding, Paragraph, Scrollbar,
+    ScrollbarState, StatefulWidget, Tabs, Widget,
+};
 use unicode_width::UnicodeWidthStr;
 
 use crate::{RgbSwatch, THEME};
@@ -59,20 +66,20 @@ impl EmailTab {
 impl Widget for EmailTab {
     fn render(self, area: Rect, buf: &mut Buffer) {
         RgbSwatch.render(area, buf);
-        let area = area.inner(&Margin {
+        let area = area.inner(Margin {
             vertical: 1,
             horizontal: 2,
         });
         Clear.render(area, buf);
-        let vertical = Layout::vertical([Constraint::Length(5), Constraint::Min(0)]);
-        let [inbox, email] = vertical.areas(area);
+        let layout = Layout::vertical([Constraint::Length(5), Constraint::Min(0)]);
+        let [inbox, email] = area.layout(&layout);
         render_inbox(self.row_index, inbox, buf);
         render_email(self.row_index, email, buf);
     }
 }
 fn render_inbox(selected_index: usize, area: Rect, buf: &mut Buffer) {
-    let vertical = Layout::vertical([Constraint::Length(1), Constraint::Min(0)]);
-    let [tabs, inbox] = vertical.areas(area);
+    let layout = Layout::vertical([Constraint::Length(1), Constraint::Min(0)]);
+    let [tabs, inbox] = area.layout(&layout);
     let theme = THEME.email;
     Tabs::new(vec![" Inbox ", " Sent ", " Drafts "])
         .style(theme.tabs)
@@ -87,13 +94,10 @@ fn render_inbox(selected_index: usize, area: Rect, buf: &mut Buffer) {
         .map(|e| e.from.width())
         .max()
         .unwrap_or_default();
-    let items = EMAILS
-        .iter()
-        .map(|e| {
-            let from = format!("{:width$}", e.from, width = from_width).into();
-            ListItem::new(Line::from(vec![from, " ".into(), e.subject.into()]))
-        })
-        .collect_vec();
+    let items = EMAILS.iter().map(|e| {
+        let from = format!("{:width$}", e.from, width = from_width).into();
+        ListItem::new(Line::from(vec![from, " ".into(), e.subject.into()]))
+    });
     let mut state = ListState::default().with_selected(Some(selected_index));
     StatefulWidget::render(
         List::new(items)
@@ -126,8 +130,8 @@ fn render_email(selected_index: usize, area: Rect, buf: &mut Buffer) {
     let inner = block.inner(area);
     block.render(area, buf);
     if let Some(email) = email {
-        let vertical = Layout::vertical([Constraint::Length(3), Constraint::Min(0)]);
-        let [headers_area, body_area] = vertical.areas(inner);
+        let layout = Layout::vertical([Constraint::Length(3), Constraint::Min(0)]);
+        let [headers_area, body_area] = inner.layout(&layout);
         let headers = vec![
             Line::from(vec![
                 "From: ".set_style(theme.header),

examples/apps/demo2/src/tabs/recipe.rs

@@ -1,5 +1,12 @@
 use itertools::Itertools;
-use ratatui::{prelude::*, widgets::*};
+use ratatui::buffer::Buffer;
+use ratatui::layout::{Alignment, Constraint, Layout, Margin, Rect};
+use ratatui::style::{Style, Stylize};
+use ratatui::text::Line;
+use ratatui::widgets::{
+    Block, Clear, Padding, Paragraph, Row, Scrollbar, ScrollbarOrientation, ScrollbarState,
+    StatefulWidget, Table, TableState, Widget, Wrap,
+};
 
 use crate::{RgbSwatch, THEME};
 
@@ -10,13 +17,13 @@ struct Ingredient {
 }
 
 impl Ingredient {
-    #[allow(clippy::cast_possible_truncation)]
+    #[expect(clippy::cast_possible_truncation)]
     fn height(&self) -> u16 {
         self.name.lines().count() as u16
     }
 }
 
-impl<'a> From<Ingredient> for Row<'a> {
+impl From<Ingredient> for Row<'_> {
     fn from(i: Ingredient) -> Self {
         Row::new(vec![i.quantity, i.name]).height(i.height())
     }
@@ -105,7 +112,7 @@ impl RecipeTab {
 impl Widget for RecipeTab {
     fn render(self, area: Rect, buf: &mut Buffer) {
         RgbSwatch.render(area, buf);
-        let area = area.inner(&Margin {
+        let area = area.inner(Margin {
             vertical: 1,
             horizontal: 2,
         });
@@ -124,12 +131,12 @@ impl Widget for RecipeTab {
         };
         render_scrollbar(self.row_index, scrollbar_area, buf);
 
-        let area = area.inner(&Margin {
+        let area = area.inner(Margin {
             horizontal: 2,
             vertical: 1,
         });
-        let [recipe, ingredients] =
-            Layout::horizontal([Constraint::Length(44), Constraint::Min(0)]).areas(area);
+        let layout = Layout::horizontal([Constraint::Length(44), Constraint::Min(0)]);
+        let [recipe, ingredients] = area.layout(&layout);
 
         render_recipe(recipe, buf);
         render_ingredients(self.row_index, ingredients, buf);
@@ -155,7 +162,7 @@ fn render_ingredients(selected_row: usize, area: Rect, buf: &mut Buffer) {
         Table::new(rows, [Constraint::Length(7), Constraint::Length(30)])
             .block(Block::new().style(theme.ingredients))
             .header(Row::new(vec!["Qty", "Ingredient"]).style(theme.ingredients_header))
-            .highlight_style(Style::new().light_yellow()),
+            .row_highlight_style(Style::new().light_yellow()),
         area,
         buf,
         &mut state,

examples/apps/demo2/src/tabs/traceroute.rs

@@ -1,7 +1,12 @@
 use itertools::Itertools;
-use ratatui::{
-    prelude::*,
-    widgets::{canvas::*, *},
+use ratatui::buffer::Buffer;
+use ratatui::layout::{Alignment, Constraint, Layout, Margin, Rect};
+use ratatui::style::{Styled, Stylize};
+use ratatui::symbols::Marker;
+use ratatui::widgets::canvas::{self, Canvas, Map, MapResolution, Points};
+use ratatui::widgets::{
+    Block, BorderType, Clear, Padding, Row, Scrollbar, ScrollbarOrientation, ScrollbarState,
+    Sparkline, StatefulWidget, Table, TableState, Widget,
 };
 
 use crate::{RgbSwatch, THEME};
@@ -26,7 +31,7 @@ impl TracerouteTab {
 impl Widget for TracerouteTab {
     fn render(self, area: Rect, buf: &mut Buffer) {
         RgbSwatch.render(area, buf);
-        let area = area.inner(&Margin {
+        let area = area.inner(Margin {
             vertical: 1,
             horizontal: 2,
         });
@@ -34,8 +39,8 @@ impl Widget for TracerouteTab {
         Block::new().style(THEME.content).render(area, buf);
         let horizontal = Layout::horizontal([Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)]);
         let vertical = Layout::vertical([Constraint::Min(0), Constraint::Length(3)]);
-        let [left, map] = horizontal.areas(area);
-        let [hops, pings] = vertical.areas(left);
+        let [left, map] = area.layout(&horizontal);
+        let [hops, pings] = left.layout(&vertical);
 
         render_hops(self.row_index, hops, buf);
         render_ping(self.row_index, pings, buf);
@@ -45,10 +50,7 @@ impl Widget for TracerouteTab {
 
 fn render_hops(selected_row: usize, area: Rect, buf: &mut Buffer) {
     let mut state = TableState::default().with_selected(Some(selected_row));
-    let rows = HOPS
-        .iter()
-        .map(|hop| Row::new(vec![hop.host, hop.address]))
-        .collect_vec();
+    let rows = HOPS.iter().map(|hop| Row::new(vec![hop.host, hop.address]));
     let block = Block::new()
         .padding(Padding::new(1, 1, 1, 1))
         .title_alignment(Alignment::Center)
@@ -56,7 +58,7 @@ fn render_hops(selected_row: usize, area: Rect, buf: &mut Buffer) {
     StatefulWidget::render(
         Table::new(rows, [Constraint::Max(100), Constraint::Length(15)])
             .header(Row::new(vec!["Host", "Address"]).set_style(THEME.traceroute.header))
-            .highlight_style(THEME.traceroute.selected)
+            .row_highlight_style(THEME.traceroute.selected)
             .block(block),
         area,
         buf,
@@ -95,7 +97,7 @@ pub fn render_ping(progress: usize, area: Rect, buf: &mut Buffer) {
                 .title_alignment(Alignment::Center)
                 .border_type(BorderType::Thick),
         )
-        .data(&data)
+        .data(data)
         .style(THEME.traceroute.ping)
         .render(area, buf);
 }
@@ -104,7 +106,7 @@ fn render_map(selected_row: usize, area: Rect, buf: &mut Buffer) {
     let theme = THEME.traceroute.map;
     let path: Option<(&Hop, &Hop)> = HOPS.iter().tuple_windows().nth(selected_row);
     let map = Map {
-        resolution: canvas::MapResolution::High,
+        resolution: MapResolution::High,
         color: theme.color,
     };
     Canvas::default()

examples/apps/demo2/src/tabs/weather.rs

@@ -1,12 +1,14 @@
 use itertools::Itertools;
 use palette::Okhsv;
-use ratatui::{
-    prelude::*,
-    widgets::{calendar::CalendarEventStore, *},
-};
+use ratatui::buffer::Buffer;
+use ratatui::layout::{Constraint, Direction, Layout, Margin, Rect};
+use ratatui::style::{Color, Style};
+use ratatui::symbols;
+use ratatui::widgets::calendar::{CalendarEventStore, Monthly};
+use ratatui::widgets::{Bar, BarChart, BarGroup, Block, Clear, LineGauge, Padding, Widget};
 use time::OffsetDateTime;
 
-use crate::{color_from_oklab, RgbSwatch, THEME};
+use crate::{RgbSwatch, THEME, color_from_oklab};
 
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub struct WeatherTab {
@@ -28,27 +30,27 @@ impl WeatherTab {
 impl Widget for WeatherTab {
     fn render(self, area: Rect, buf: &mut Buffer) {
         RgbSwatch.render(area, buf);
-        let area = area.inner(&Margin {
+        let area = area.inner(Margin {
             vertical: 1,
             horizontal: 2,
         });
         Clear.render(area, buf);
         Block::new().style(THEME.content).render(area, buf);
 
-        let area = area.inner(&Margin {
+        let area = area.inner(Margin {
             horizontal: 2,
             vertical: 1,
         });
-        let [main, _, gauges] = Layout::vertical([
+        let tab_layout = Layout::vertical([
             Constraint::Min(0),
             Constraint::Length(1),
             Constraint::Length(1),
-        ])
-        .areas(area);
-        let [calendar, charts] =
-            Layout::horizontal([Constraint::Length(23), Constraint::Min(0)]).areas(main);
-        let [simple, horizontal] =
-            Layout::vertical([Constraint::Length(29), Constraint::Min(0)]).areas(charts);
+        ]);
+        let [main, _, gauges] = area.layout(&tab_layout);
+        let main_layout = Layout::horizontal([Constraint::Length(23), Constraint::Min(0)]);
+        let [calendar, charts] = main.layout(&main_layout);
+        let charts_layout = Layout::vertical([Constraint::Length(29), Constraint::Min(0)]);
+        let [simple, horizontal] = charts.layout(&charts_layout);
 
         render_calendar(calendar, buf);
         render_simple_barchart(simple, buf);
@@ -59,7 +61,7 @@ impl Widget for WeatherTab {
 
 fn render_calendar(area: Rect, buf: &mut Buffer) {
     let date = OffsetDateTime::now_utc().date();
-    calendar::Monthly::new(date, CalendarEventStore::today(Style::new().red().bold()))
+    Monthly::new(date, CalendarEventStore::today(Style::new().red().bold()))
         .block(Block::new().padding(Padding::new(0, 0, 2, 0)))
         .show_month_header(Style::new().bold())
         .show_weekdays_header(Style::new().italic())
@@ -82,7 +84,7 @@ fn render_simple_barchart(area: Rect, buf: &mut Buffer) {
             Bar::default()
                 .value(value)
                 // This doesn't actually render correctly as the text is too wide for the bar
-                // See https://github.com/ratatui-org/ratatui/issues/513 for more info
+                // See https://github.com/ratatui/ratatui/issues/513 for more info
                 // (the demo GIFs hack around this by hacking the calculation in bars.rs)
                 .text_value(format!("{value}°"))
                 .style(if value > 70 {
@@ -95,7 +97,7 @@ fn render_simple_barchart(area: Rect, buf: &mut Buffer) {
                 } else {
                     Style::new().fg(Color::DarkGray).bg(Color::Yellow).bold()
                 })
-                .label(label.into())
+                .label(label)
         })
         .collect_vec();
     let group = BarGroup::default().bars(&data);
@@ -109,15 +111,15 @@ fn render_simple_barchart(area: Rect, buf: &mut Buffer) {
 fn render_horizontal_barchart(area: Rect, buf: &mut Buffer) {
     let bg = Color::Rgb(32, 48, 96);
     let data = [
-        Bar::default().text_value("Winter 37-51".into()).value(51),
-        Bar::default().text_value("Spring 40-65".into()).value(65),
-        Bar::default().text_value("Summer 54-77".into()).value(77),
+        Bar::default().text_value("Winter 37-51").value(51),
+        Bar::default().text_value("Spring 40-65").value(65),
+        Bar::default().text_value("Summer 54-77").value(77),
         Bar::default()
-            .text_value("Fall 41-71".into())
+            .text_value("Fall 41-71")
             .value(71)
             .value_style(Style::new().bold()), // current season
     ];
-    let group = BarGroup::default().label("GPU".into()).bars(&data);
+    let group = BarGroup::default().label("GPU").bars(&data);
     BarChart::default()
         .block(Block::new().padding(Padding::new(0, 0, 2, 0)))
         .direction(Direction::Horizontal)
@@ -128,20 +130,20 @@ fn render_horizontal_barchart(area: Rect, buf: &mut Buffer) {
         .render(area, buf);
 }
 
-#[allow(clippy::cast_precision_loss)]
+#[expect(clippy::cast_precision_loss)]
 pub fn render_gauge(progress: usize, area: Rect, buf: &mut Buffer) {
     let percent = (progress * 3).min(100) as f64;
 
     render_line_gauge(percent, area, buf);
 }
 
-#[allow(clippy::cast_possible_truncation)]
+#[expect(clippy::cast_possible_truncation)]
 fn render_line_gauge(percent: f64, area: Rect, buf: &mut Buffer) {
     // cycle color hue based on the percent for a neat effect yellow -> red
     let hue = 90.0 - (percent as f32 * 0.6);
     let value = Okhsv::max_value();
-    let fg = color_from_oklab(hue, Okhsv::max_saturation(), value);
-    let bg = color_from_oklab(hue, Okhsv::max_saturation(), value * 0.5);
+    let filled_color = color_from_oklab(hue, Okhsv::max_saturation(), value);
+    let unfilled_color = color_from_oklab(hue, Okhsv::max_saturation(), value * 0.5);
     let label = if percent < 100.0 {
         format!("Downloading: {percent}%")
     } else {
@@ -151,7 +153,9 @@ fn render_line_gauge(percent: f64, area: Rect, buf: &mut Buffer) {
         .ratio(percent / 100.0)
         .label(label)
         .style(Style::new().light_blue())
-        .gauge_style(Style::new().fg(fg).bg(bg))
-        .line_set(symbols::line::THICK)
+        .filled_style(Style::new().fg(filled_color))
+        .unfilled_style(Style::new().fg(unfilled_color))
+        .filled_symbol(symbols::line::THICK_HORIZONTAL)
+        .unfilled_symbol(symbols::line::THICK_HORIZONTAL)
         .render(area, buf);
 }

examples/apps/demo2/src/theme.rs

@@ -1,4 +1,4 @@
-use ratatui::prelude::*;
+use ratatui::style::{Color, Modifier, Style};
 
 pub struct Theme {
     pub root: Style,
@@ -22,10 +22,8 @@ pub struct KeyBinding {
 }
 
 pub struct Logo {
-    pub rat: Color,
     pub rat_eye: Color,
     pub rat_eye_alt: Color,
-    pub term: Color,
 }
 
 pub struct Email {
@@ -77,10 +75,8 @@ pub const THEME: Theme = Theme {
     description: Style::new().fg(LIGHT_GRAY).bg(DARK_BLUE),
     description_title: Style::new().fg(LIGHT_GRAY).add_modifier(Modifier::BOLD),
     logo: Logo {
-        rat: WHITE,
         rat_eye: BLACK,
         rat_eye_alt: RED,
-        term: BLACK,
     },
     key_binding: KeyBinding {
         key: Style::new().fg(BLACK).bg(DARK_GRAY),

examples/apps/flex/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "flex"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm.workspace = true
+ratatui.workspace = true
+strum.workspace = true
+
+[lints]
+workspace = true

examples/apps/flex/README.md

@@ -0,0 +1,9 @@
+# Flex demo
+
+This interactive example shows how to use the flex layouts.
+
+To run this demo:
+
+```shell
+cargo run -p flex
+```

examples/apps/flex/src/main.rs

@@ -1,41 +1,39 @@
-//! # [Ratatui] Flex example
-//!
-//! The latest version of this example is available in the [examples] folder in the repository.
-//!
-//! Please note that the examples are designed to be run against the `main` branch of the Github
-//! repository. This means that you may not be able to compile with the latest release version on
-//! crates.io, or the one that you have installed locally.
-//!
-//! See the [examples readme] for more information on finding examples that match the version of the
-//! library you are using.
-//!
-//! [Ratatui]: https://github.com/ratatui-org/ratatui
-//! [examples]: https://github.com/ratatui-org/ratatui/blob/main/examples
-//! [examples readme]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md
+/// A Ratatui example that demonstrates different types of flex layouts.
+///
+/// You can also change the spacing between the constraints, and toggle between different types
+/// of flex layouts.
+///
+/// This example runs with the Ratatui library code in the branch that you are currently
+/// reading. See the [`latest`] branch for the code which works with the most recent Ratatui
+/// release.
+///
+/// [`latest`]: https://github.com/ratatui/ratatui/tree/latest
+use std::num::NonZeroUsize;
 
-#![allow(clippy::enum_glob_use, clippy::wildcard_imports)]
-
-use std::io::{self, stdout};
-
-use color_eyre::{config::HookBuilder, Result};
-use crossterm::{
-    event::{self, Event, KeyCode, KeyEventKind},
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    ExecutableCommand,
-};
-use ratatui::{
-    layout::{Constraint::*, Flex},
-    prelude::*,
-    style::palette::tailwind,
-    symbols::line,
-    widgets::{block::Title, *},
+use color_eyre::Result;
+use crossterm::event::{self, KeyCode};
+use ratatui::DefaultTerminal;
+use ratatui::buffer::Buffer;
+use ratatui::layout::Constraint::{self, Fill, Length, Max, Min, Percentage, Ratio};
+use ratatui::layout::{Alignment, Flex, Layout, Rect};
+use ratatui::style::palette::tailwind;
+use ratatui::style::{Color, Modifier, Style, Stylize};
+use ratatui::symbols::{self, line};
+use ratatui::text::{Line, Text};
+use ratatui::widgets::{
+    Block, Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState, StatefulWidget, Tabs, Widget,
 };
 use strum::{Display, EnumIter, FromRepr, IntoEnumIterator};
 
+fn main() -> Result<()> {
+    color_eyre::install()?;
+    ratatui::run(|terminal| App::default().run(terminal))
+}
+
 const EXAMPLE_DATA: &[(&str, &[Constraint])] = &[
     (
         "Min(u16) takes any excess space always",
-        &[Length(10), Min(10), Max(10), Percentage(10), Ratio(1,10)],
+        &[Length(10), Min(10), Max(10), Percentage(10), Ratio(1, 10)],
     ),
     (
         "Fill(u16) takes any excess space always",
@@ -43,20 +41,18 @@ const EXAMPLE_DATA: &[(&str, &[Constraint])] = &[
     ),
     (
         "Here's all constraints in one line",
-        &[Length(10), Min(10), Max(10), Percentage(10), Ratio(1,10), Fill(1)],
-    ),
-    (
-        "",
-        &[Max(50), Min(50)],
-    ),
-    (
-        "",
-        &[Max(20), Length(10)],
-    ),
-    (
-        "",
-        &[Max(20), Length(10)],
+        &[
+            Length(10),
+            Min(10),
+            Max(10),
+            Percentage(10),
+            Ratio(1, 10),
+            Fill(1),
+        ],
     ),
+    ("", &[Max(50), Min(50)]),
+    ("", &[Max(20), Length(10)]),
+    ("", &[Max(20), Length(10)]),
     (
         "Min grows always but also allows Fill to grow",
         &[Percentage(50), Fill(1), Fill(2), Min(50)],
@@ -66,44 +62,58 @@ const EXAMPLE_DATA: &[(&str, &[Constraint])] = &[
         &[Length(20), Length(20), Percentage(20)],
     ),
     ("", &[Length(20), Percentage(20), Length(20)]),
-    ("A lowest priority constraint will be broken before a high priority constraint", &[Ratio(1,4), Percentage(20)]),
-    ("`Length` is higher priority than `Percentage`", &[Percentage(20), Length(10)]),
-    ("`Min/Max` is higher priority than `Length`", &[Length(10), Max(20)]),
+    (
+        "A lowest priority constraint will be broken before a high priority constraint",
+        &[Ratio(1, 4), Percentage(20)],
+    ),
+    (
+        "`Length` is higher priority than `Percentage`",
+        &[Percentage(20), Length(10)],
+    ),
+    (
+        "`Min/Max` is higher priority than `Length`",
+        &[Length(10), Max(20)],
+    ),
     ("", &[Length(100), Min(20)]),
-    ("`Length` is higher priority than `Min/Max`", &[Max(20), Length(10)]),
+    (
+        "`Length` is higher priority than `Min/Max`",
+        &[Max(20), Length(10)],
+    ),
     ("", &[Min(20), Length(90)]),
-    ("Fill is the lowest priority and will fill any excess space", &[Fill(1), Ratio(1, 4)]),
-    ("Fill can be used to scale proportionally with other Fill blocks", &[Fill(1), Percentage(20), Fill(2)]),
+    (
+        "Fill is the lowest priority and will fill any excess space",
+        &[Fill(1), Ratio(1, 4)],
+    ),
+    (
+        "Fill can be used to scale proportionally with other Fill blocks",
+        &[Fill(1), Percentage(20), Fill(2)],
+    ),
     ("", &[Ratio(1, 3), Percentage(20), Ratio(2, 3)]),
-    ("Legacy will stretch the last lowest priority constraint\nStretch will only stretch equal weighted constraints", &[Length(20), Length(15)]),
+    (
+        "Legacy will stretch the last lowest priority constraint\nStretch will only stretch equal weighted constraints",
+        &[Length(20), Length(15)],
+    ),
     ("", &[Percentage(20), Length(15)]),
-    ("`Fill(u16)` fills up excess space, but is lower priority to spacers.\ni.e. Fill will only have widths in Flex::Stretch and Flex::Legacy", &[Fill(1), Fill(1)]),
+    (
+        "`Fill(u16)` fills up excess space, but is lower priority to spacers.\ni.e. Fill will only have widths in Flex::Stretch and Flex::Legacy",
+        &[Fill(1), Fill(1)],
+    ),
     ("", &[Length(20), Length(20)]),
     (
         "When not using `Flex::Stretch` or `Flex::Legacy`,\n`Min(u16)` and `Max(u16)` collapse to their lowest values",
         &[Min(20), Max(20)],
     ),
-    (
-        "",
-        &[Max(20)],
-    ),
+    ("", &[Max(20)]),
     ("", &[Min(20), Max(20), Length(20), Length(20)]),
     ("", &[Fill(0), Fill(0)]),
     (
         "`Fill(1)` can be to scale with respect to other `Fill(2)`",
         &[Fill(1), Fill(2)],
     ),
-    (
-        "",
-        &[Fill(1), Min(10), Max(10), Fill(2)],
-    ),
+    ("", &[Fill(1), Min(10), Max(10), Fill(2)]),
     (
         "`Fill(0)` collapses if there are other non-zero `Fill(_)`\nconstraints. e.g. `[Fill(0), Fill(0), Fill(1)]`:",
-        &[
-            Fill(0),
-            Fill(0),
-            Fill(1),
-        ],
+        &[Fill(0), Fill(0), Fill(1)],
     ),
 ];
 
@@ -143,26 +153,22 @@ enum SelectedTab {
     Center,
     End,
     SpaceAround,
+    SpaceEvenly,
     SpaceBetween,
 }
 
-fn main() -> Result<()> {
-    // assuming the user changes spacing about a 100 times or so
-    Layout::init_cache(EXAMPLE_DATA.len() * SelectedTab::iter().len() * 100);
-    init_error_hooks()?;
-    let terminal = init_terminal()?;
-    App::default().run(terminal)?;
-
-    restore_terminal()?;
-    Ok(())
-}
-
 impl App {
-    fn run(&mut self, mut terminal: Terminal<impl Backend>) -> Result<()> {
-        self.draw(&mut terminal)?;
+    fn run(mut self, terminal: &mut DefaultTerminal) -> Result<()> {
+        // increase the layout cache to account for the number of layout events. This ensures that
+        // layout is not generally reprocessed on every frame (which would lead to possible janky
+        // results when there are more than one possible solution to the requested layout). This
+        // assumes the user changes spacing about a 100 times or so.
+        let cache_size = EXAMPLE_DATA.len() * SelectedTab::iter().len() * 100;
+        Layout::init_cache(NonZeroUsize::new(cache_size).unwrap());
+
         while self.is_running() {
+            terminal.draw(|frame| frame.render_widget(self, frame.area()))?;
             self.handle_events()?;
-            self.draw(&mut terminal)?;
         }
         Ok(())
     }
@@ -171,27 +177,20 @@ impl App {
         self.state == AppState::Running
     }
 
-    fn draw(self, terminal: &mut Terminal<impl Backend>) -> io::Result<()> {
-        terminal.draw(|frame| frame.render_widget(self, frame.size()))?;
-        Ok(())
-    }
-
     fn handle_events(&mut self) -> Result<()> {
-        use KeyCode::*;
-        match event::read()? {
-            Event::Key(key) if key.kind == KeyEventKind::Press => match key.code {
-                Char('q') | Esc => self.quit(),
-                Char('l') | Right => self.next(),
-                Char('h') | Left => self.previous(),
-                Char('j') | Down => self.down(),
-                Char('k') | Up => self.up(),
-                Char('g') | Home => self.top(),
-                Char('G') | End => self.bottom(),
-                Char('+') => self.increment_spacing(),
-                Char('-') => self.decrement_spacing(),
+        if let Some(key) = event::read()?.as_key_press_event() {
+            match key.code {
+                KeyCode::Char('q') | KeyCode::Esc => self.quit(),
+                KeyCode::Char('l') | KeyCode::Right => self.next(),
+                KeyCode::Char('h') | KeyCode::Left => self.previous(),
+                KeyCode::Char('j') | KeyCode::Down => self.down(),
+                KeyCode::Char('k') | KeyCode::Up => self.up(),
+                KeyCode::Char('g') | KeyCode::Home => self.top(),
+                KeyCode::Char('G') | KeyCode::End => self.bottom(),
+                KeyCode::Char('+') => self.increment_spacing(),
+                KeyCode::Char('-') => self.decrement_spacing(),
                 _ => (),
-            },
-            _ => {}
+            }
         }
         Ok(())
     }
@@ -204,7 +203,7 @@ impl App {
         self.selected_tab = self.selected_tab.previous();
     }
 
-    fn up(&mut self) {
+    const fn up(&mut self) {
         self.scroll_offset = self.scroll_offset.saturating_sub(1);
     }
 
@@ -215,7 +214,7 @@ impl App {
             .min(max_scroll_offset());
     }
 
-    fn top(&mut self) {
+    const fn top(&mut self) {
         self.scroll_offset = 0;
     }
 
@@ -223,15 +222,15 @@ impl App {
         self.scroll_offset = max_scroll_offset();
     }
 
-    fn increment_spacing(&mut self) {
+    const fn increment_spacing(&mut self) {
         self.spacing = self.spacing.saturating_add(1);
     }
 
-    fn decrement_spacing(&mut self) {
+    const fn decrement_spacing(&mut self) {
         self.spacing = self.spacing.saturating_sub(1);
     }
 
-    fn quit(&mut self) {
+    const fn quit(&mut self) {
         self.state = AppState::Quit;
     }
 }
@@ -257,7 +256,7 @@ fn example_height() -> u16 {
 impl Widget for App {
     fn render(self, area: Rect, buf: &mut Buffer) {
         let layout = Layout::vertical([Length(3), Length(1), Fill(0)]);
-        let [tabs, axis, demo] = layout.areas(area);
+        let [tabs, axis, demo] = area.layout(&layout);
         self.tabs().render(tabs, buf);
         let scroll_needed = self.render_demo(demo, buf);
         let axis_width = if scroll_needed {
@@ -273,7 +272,7 @@ impl App {
     fn tabs(self) -> impl Widget {
         let tab_titles = SelectedTab::iter().map(SelectedTab::to_tab_title);
         let block = Block::new()
-            .title(Title::from("Flex Layouts ".bold()))
+            .title("Flex Layouts ".bold())
             .title(" Use ◄ ► to change tab, ▲ ▼  to scroll, - + to change spacing ");
         Tabs::new(tab_titles)
             .block(block)
@@ -303,7 +302,7 @@ impl App {
     /// into the main buffer. This is done to make it possible to handle scrolling easily.
     ///
     /// Returns bool indicating whether scroll was needed
-    #[allow(clippy::cast_possible_truncation)]
+    #[expect(clippy::cast_possible_truncation)]
     fn render_demo(self, area: Rect, buf: &mut Buffer) -> bool {
         // render demo content into a separate buffer so all examples fit we add an extra
         // area.height to make sure the last example is fully visible even when the scroll offset is
@@ -334,7 +333,7 @@ impl App {
         for (i, cell) in visible_content.enumerate() {
             let x = i as u16 % area.width;
             let y = i as u16 / area.width;
-            *buf.get_mut(area.x + x, area.y + y) = cell;
+            buf[(area.x + x, area.y + y)] = cell;
         }
 
         if scrollbar_needed {
@@ -364,15 +363,16 @@ impl SelectedTab {
 
     /// Convert a `SelectedTab` into a `Line` to display it by the `Tabs` widget.
     fn to_tab_title(value: Self) -> Line<'static> {
-        use tailwind::*;
+        use tailwind::{INDIGO, ORANGE, SKY};
         let text = value.to_string();
         let color = match value {
             Self::Legacy => ORANGE.c400,
             Self::Start => SKY.c400,
             Self::Center => SKY.c300,
             Self::End => SKY.c200,
-            Self::SpaceAround => INDIGO.c400,
+            Self::SpaceEvenly => INDIGO.c400,
             Self::SpaceBetween => INDIGO.c300,
+            Self::SpaceAround => INDIGO.c500,
         };
         format!(" {text} ").fg(color).bg(Color::Black).into()
     }
@@ -387,8 +387,9 @@ impl StatefulWidget for SelectedTab {
             Self::Start => Self::render_examples(area, buf, Flex::Start, spacing),
             Self::Center => Self::render_examples(area, buf, Flex::Center, spacing),
             Self::End => Self::render_examples(area, buf, Flex::End, spacing),
-            Self::SpaceAround => Self::render_examples(area, buf, Flex::SpaceAround, spacing),
+            Self::SpaceEvenly => Self::render_examples(area, buf, Flex::SpaceEvenly, spacing),
             Self::SpaceBetween => Self::render_examples(area, buf, Flex::SpaceBetween, spacing),
+            Self::SpaceAround => Self::render_examples(area, buf, Flex::SpaceAround, spacing),
         }
     }
 }
@@ -420,7 +421,7 @@ impl Widget for Example {
     fn render(self, area: Rect, buf: &mut Buffer) {
         let title_height = get_description_height(&self.description);
         let layout = Layout::vertical([Length(title_height), Fill(0)]);
-        let [title, illustrations] = layout.areas(area);
+        let [title, illustrations] = area.layout(&layout);
 
         let (blocks, spacers) = Layout::horizontal(&self.constraints)
             .flex(self.flex)
@@ -509,7 +510,7 @@ impl Example {
 }
 
 const fn color_for_constraint(constraint: Constraint) -> Color {
-    use tailwind::*;
+    use tailwind::{BLUE, SLATE};
     match constraint {
         Constraint::Min(_) => BLUE.c900,
         Constraint::Max(_) => BLUE.c800,
@@ -520,36 +521,7 @@ const fn color_for_constraint(constraint: Constraint) -> Color {
     }
 }
 
-fn init_error_hooks() -> Result<()> {
-    let (panic, error) = HookBuilder::default().into_hooks();
-    let panic = panic.into_panic_hook();
-    let error = error.into_eyre_hook();
-    color_eyre::eyre::set_hook(Box::new(move |e| {
-        let _ = restore_terminal();
-        error(e)
-    }))?;
-    std::panic::set_hook(Box::new(move |info| {
-        let _ = restore_terminal();
-        panic(info);
-    }));
-    Ok(())
-}
-
-fn init_terminal() -> Result<Terminal<impl Backend>> {
-    enable_raw_mode()?;
-    stdout().execute(EnterAlternateScreen)?;
-    let backend = CrosstermBackend::new(stdout());
-    let terminal = Terminal::new(backend)?;
-    Ok(terminal)
-}
-
-fn restore_terminal() -> Result<()> {
-    disable_raw_mode()?;
-    stdout().execute(LeaveAlternateScreen)?;
-    Ok(())
-}
-
-#[allow(clippy::cast_possible_truncation)]
+#[expect(clippy::cast_possible_truncation)]
 fn get_description_height(s: &str) -> u16 {
     if s.is_empty() {
         0

examples/apps/gauge/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "gauge"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm.workspace = true
+ratatui.workspace = true
+
+[lints]
+workspace = true

examples/apps/gauge/README.md

@@ -0,0 +1,9 @@
+# Gauge demo
+
+This example shows different types of gauges.
+
+To run this demo:
+
+```shell
+cargo run -p gauge
+```

examples/apps/gauge/src/main.rs

@@ -1,33 +1,21 @@
-//! # [Ratatui] Gauge example
-//!
-//! The latest version of this example is available in the [examples] folder in the repository.
-//!
-//! Please note that the examples are designed to be run against the `main` branch of the Github
-//! repository. This means that you may not be able to compile with the latest release version on
-//! crates.io, or the one that you have installed locally.
-//!
-//! See the [examples readme] for more information on finding examples that match the version of the
-//! library you are using.
-//!
-//! [Ratatui]: https://github.com/ratatui-org/ratatui
-//! [examples]: https://github.com/ratatui-org/ratatui/blob/main/examples
-//! [examples readme]: https://github.com/ratatui-org/ratatui/blob/main/examples/README.md
+/// A Ratatui example that demonstrates different types of gauges.
+///
+/// This example runs with the Ratatui library code in the branch that you are currently
+/// reading. See the [`latest`] branch for the code which works with the most recent Ratatui
+/// release.
+///
+/// [`latest`]: https://github.com/ratatui/ratatui/tree/latest
+use std::time::Duration;
 
-#![allow(clippy::enum_glob_use)]
-
-use std::{io::stdout, time::Duration};
-
-use color_eyre::{config::HookBuilder, Result};
-use crossterm::{
-    event::{self, Event, KeyCode, KeyEventKind},
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-    ExecutableCommand,
-};
-use ratatui::{
-    prelude::*,
-    style::palette::tailwind,
-    widgets::{block::Title, Block, Borders, Gauge, Padding, Paragraph},
-};
+use color_eyre::Result;
+use crossterm::event::{self, KeyCode};
+use ratatui::DefaultTerminal;
+use ratatui::buffer::Buffer;
+use ratatui::layout::{Alignment, Constraint, Layout, Rect};
+use ratatui::style::palette::tailwind;
+use ratatui::style::{Color, Style, Stylize};
+use ratatui::text::{Line, Span};
+use ratatui::widgets::{Block, Borders, Gauge, Padding, Paragraph, Widget};
 
 const GAUGE1_COLOR: Color = tailwind::RED.c800;
 const GAUGE2_COLOR: Color = tailwind::GREEN.c800;
@@ -54,28 +42,20 @@ enum AppState {
 }
 
 fn main() -> Result<()> {
-    init_error_hooks()?;
-    let terminal = init_terminal()?;
-    App::default().run(terminal)?;
-    restore_terminal()?;
-    Ok(())
+    color_eyre::install()?;
+    ratatui::run(|terminal| App::default().run(terminal))
 }
 
 impl App {
-    fn run(&mut self, mut terminal: Terminal<impl Backend>) -> Result<()> {
+    fn run(mut self, terminal: &mut DefaultTerminal) -> Result<()> {
         while self.state != AppState::Quitting {
-            self.draw(&mut terminal)?;
+            terminal.draw(|frame| frame.render_widget(&self, frame.area()))?;
             self.handle_events()?;
             self.update(terminal.size()?.width);
         }
         Ok(())
     }
 
-    fn draw(&self, terminal: &mut Terminal<impl Backend>) -> Result<()> {
-        terminal.draw(|f| f.render_widget(self, f.size()))?;
-        Ok(())
-    }
-
     fn update(&mut self, terminal_width: u16) {
         if self.state != AppState::Started {
             return;
@@ -96,39 +76,37 @@ impl App {
 
     fn handle_events(&mut self) -> Result<()> {
         let timeout = Duration::from_secs_f32(1.0 / 20.0);
-        if event::poll(timeout)? {
-            if let Event::Key(key) = event::read()? {
-                if key.kind == KeyEventKind::Press {
-                    use KeyCode::*;
-                    match key.code {
-                        Char(' ') | Enter => self.start(),
-                        Char('q') | Esc => self.quit(),
-                        _ => {}
-                    }
-                }
+        if !event::poll(timeout)? {
+            return Ok(());
+        }
+        if let Some(key) = event::read()?.as_key_press_event() {
+            match key.code {
+                KeyCode::Char(' ') | KeyCode::Enter => self.start(),
+                KeyCode::Char('q') | KeyCode::Esc => self.quit(),
+                _ => {}
             }
         }
         Ok(())
     }
 
-    fn start(&mut self) {
+    const fn start(&mut self) {
         self.state = AppState::Started;
     }
 
-    fn quit(&mut self) {
+    const fn quit(&mut self) {
         self.state = AppState::Quitting;
     }
 }
 
 impl Widget for &App {
-    #[allow(clippy::similar_names)]
+    #[expect(clippy::similar_names)]
     fn render(self, area: Rect, buf: &mut Buffer) {
-        use Constraint::*;
+        use Constraint::{Length, Min, Ratio};
         let layout = Layout::vertical([Length(2), Min(0), Length(1)]);
-        let [header_area, gauge_area, footer_area] = layout.areas(area);
+        let [header_area, gauge_area, footer_area] = area.layout(&layout);
 
         let layout = Layout::vertical([Ratio(1, 4); 4]);
-        let [gauge1_area, gauge2_area, gauge3_area, gauge4_area] = layout.areas(gauge_area);
+        let [gauge1_area, gauge2_area, gauge3_area, gauge4_area] = gauge_area.layout(&layout);
 
         render_header(header_area, buf);
         render_footer(footer_area, buf);
@@ -204,40 +182,11 @@ impl App {
     }
 }
 
-fn title_block(title: &str) -> Block {
-    let title = Title::from(title).alignment(Alignment::Center);
+fn title_block(title: &str) -> Block<'_> {
+    let title = Line::from(title).centered();
     Block::new()
         .borders(Borders::NONE)
         .padding(Padding::vertical(1))
         .title(title)
         .fg(CUSTOM_LABEL_COLOR)
 }
-
-fn init_error_hooks() -> color_eyre::Result<()> {
-    let (panic, error) = HookBuilder::default().into_hooks();
-    let panic = panic.into_panic_hook();
-    let error = error.into_eyre_hook();
-    color_eyre::eyre::set_hook(Box::new(move |e| {
-        let _ = restore_terminal();
-        error(e)
-    }))?;
-    std::panic::set_hook(Box::new(move |info| {
-        let _ = restore_terminal();
-        panic(info);
-    }));
-    Ok(())
-}
-
-fn init_terminal() -> color_eyre::Result<Terminal<impl Backend>> {
-    enable_raw_mode()?;
-    stdout().execute(EnterAlternateScreen)?;
-    let backend = CrosstermBackend::new(stdout());
-    let terminal = Terminal::new(backend)?;
-    Ok(terminal)
-}
-
-fn restore_terminal() -> color_eyre::Result<()> {
-    disable_raw_mode()?;
-    stdout().execute(LeaveAlternateScreen)?;
-    Ok(())
-}

examples/apps/hello-world/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "hello-world"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm.workspace = true
+ratatui.workspace = true
+
+[lints]
+workspace = true

examples/apps/hello-world/README.md

@@ -0,0 +1,9 @@
+# Hello World demo
+
+This example shows how to create a simple TUI with a text.
+
+To run this demo:
+
+```shell
+cargo run -p hello-world
+```

examples/apps/hello-world/src/main.rs

@@ -0,0 +1,62 @@
+/// A Ratatui example that demonstrates a basic hello world application.
+///
+/// This example runs with the Ratatui library code in the branch that you are currently
+/// reading. See the [`latest`] branch for the code which works with the most recent Ratatui
+/// release.
+///
+/// [`latest`]: https://github.com/ratatui/ratatui/tree/latest
+use std::time::Duration;
+
+use color_eyre::Result;
+use color_eyre::eyre::Context;
+use crossterm::event::{self, KeyCode};
+use ratatui::widgets::Paragraph;
+use ratatui::{DefaultTerminal, Frame};
+
+/// This is a bare minimum example. There are many approaches to running an application loop, so
+/// this is not meant to be prescriptive. It is only meant to demonstrate the basic setup and
+/// teardown of a terminal application.
+///
+/// This example does not handle events or update the application state. It just draws a greeting
+/// and exits when the user presses 'q'.
+fn main() -> Result<()> {
+    color_eyre::install()?; // augment errors / panics with easy to read messages
+    ratatui::run(run).context("failed to run app")
+}
+
+/// Run the application loop. This is where you would handle events and update the application
+/// state. This example exits when the user presses 'q'. Other styles of application loops are
+/// possible, for example, you could have multiple application states and switch between them based
+/// on events, or you could have a single application state and update it based on events.
+fn run(terminal: &mut DefaultTerminal) -> Result<()> {
+    loop {
+        terminal.draw(render)?;
+        if should_quit()? {
+            break;
+        }
+    }
+    Ok(())
+}
+
+/// Render the application. This is where you would draw the application UI. This example draws a
+/// greeting.
+fn render(frame: &mut Frame) {
+    let greeting = Paragraph::new("Hello World! (press 'q' to quit)");
+    frame.render_widget(greeting, frame.area());
+}
+
+/// Check if the user has pressed 'q'. This is where you would handle events. This example just
+/// checks if the user has pressed 'q' and returns true if they have. It does not handle any other
+/// events. There is a 250ms timeout on the event poll to ensure that the terminal is rendered at
+/// least once every 250ms. This allows you to do other work in the application loop, such as
+/// updating the application state, without blocking the event loop for too long.
+fn should_quit() -> Result<bool> {
+    if event::poll(Duration::from_millis(250)).context("event poll failed")? {
+        let q_pressed = event::read()
+            .context("event read failed")?
+            .as_key_press_event()
+            .is_some_and(|key| key.code == KeyCode::Char('q'));
+        return Ok(q_pressed);
+    }
+    Ok(false)
+}

examples/apps/hyperlink/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "hyperlink"
+publish = false
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+color-eyre.workspace = true
+crossterm.workspace = true
+itertools.workspace = true
+ratatui.workspace = true
+
+[lints]
+workspace = true