Add backwards fill

Remove target entirely
Allow user to specify offset directly
2021-10-15 11:33:53 -07:00 · 2021-10-15 11:12:59 -07:00 · 2021-10-15 11:12:14 -07:00 · 2021-10-15 10:52:18 -07:00 · 2021-10-15 10:48:12 -07:00
106 changed files with 3755 additions and 12214 deletions
--- a/.cargo-husky/hooks/pre-push
+++ b/.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
--- a/.cz.toml
+++ b/.cz.toml
@@ -1,78 +0,0 @@
-# configuration for https://github.com/commitizen/cz-cli
-
-[tool.commitizen]
-name = "cz_customize"
-tag_format = "$version"
-version_type = "semver"
-version_provider = "cargo"
-update_changelog_on_bump = true
-major_version_zero = true
-use_shortcuts = true
-
-[tool.commitizen.customize]
-message_template = """{{change_type}}({{scope}}): {{subject}}
-
-{% if body %}\
-{{body}}\
-{% endif %}
-
-{%if is_breaking_change %}\
-BREAKING_CHANGE: \
-{% endif %}\
-{{footer}}\
-"""
-example = "feature: this feature enable customize through config file"
-schema = "<type>(<scope>): <subject>\n\n<body>\n\n<footer>"
-schema_pattern = "(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)\\(\\w+\\):\\s(?P<subject>.*)(\\n\\n(?P<body>.*))?(\\n\\n(?P<footer>.*))?"
-
-# The order needs to be preserved, as it influences the order when executing cz commit/cz c
-
-# Change types
-[[tool.commitizen.customize.questions]]
-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" },
-]
-message = "Select the type of change you are committing"
-
-# The scope of the change, can be a file, class name or other context
-[[tool.commitizen.customize.questions]]
-type = "input"
-name = "scope"
-message = "What is the scope of this change? (class or file name): (press [enter] to skip)\n"
-
-# Summary of the changes
-[[tool.commitizen.customize.questions]]
-"type" = "input"
-"name" = "subject"
-"message" = "Write a short and imperative summary of the code changes: (lower case and no period)\n"
-
-# The commit body, elaborate the changes if need be.
-[[tool.commitizen.customize.questions]]
-type = "input"
-name = "body"
-message = "Provide additional contextual information about the code changes: (press [enter] to skip)\n"
-
-# Specify if the changes are breaking
-[[tool.commitizen.customize.questions]]
-type = "confirm"
-name = "is_breaking_change"
-message = "Is this a BREAKING CHANGE?"
-default = false
-
-# Reference closing issues and share other
-[[tool.commitizen.customize.questions]]
-type = "input"
-name = "footer"
-message = "Footer. Information about Breaking Changes and reference issues that this commit closes: (press [enter] to skip)"
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,8 +0,0 @@
-# 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
-
-# Maintainers
-* @orhun @mindoodoo @sayanarijit @sophacles @joshka
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -7,7 +7,7 @@ assignees: ''
 ---

 <!--
-Hi there, sorry `ratatui` is not working as expected.
+Hi there, sorry `tui` is not working as expected.
 Please fill this bug report conscientiously.
 A detailed and complete issue is more likely to be processed quickly.
 -->
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1 +1,17 @@
-<!-- Please read CONTRIBUTING.md before submitting any pull request. -->
+## Description
+<!--
+A clear and concise description of what this PR changes.
+-->
+
+## Testing guidelines
+<!--
+A clear and concise description of how the changes can be tested.
+For example, you can include a command to run the relevant tests or examples.
+You can also include screenshots of the expected behavior.
+-->
+
+## Checklist
+
+* [ ] I have read the [contributing guidelines](../CONTRIBUTING.md).
+* [ ] I have added relevant tests.
+* [ ] I have documented all new additions.
--- a/.github/workflows/cd.yml
+++ b/.github/workflows/cd.yml
@@ -1,19 +0,0 @@
-name: Continuous Deployment
-
-on:
-  push:
-    tags:
-      - "v*.*.*"
-
-jobs:
-  publish:
-    name: Publish on crates.io
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@v3
-      - name: Publish
-        uses: actions-rs/cargo@v1
-        with:
-          command: publish
-          args: --token ${{ secrets.CARGO_TOKEN }}
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,121 +1,85 @@
 on:
  push:
    branches:
-      - feat-wrapping
-      - main
+      - master
  pull_request:
    branches:
-      - main
-      - feat-wrapping
-  merge_group:
-
+      - master

 name: CI

+env:
+  CI_CARGO_MAKE_VERSION: 0.32.9
+
 jobs:
-  build:
+  linux:
+    name: Linux
+    runs-on: ubuntu-latest
    strategy:
      matrix:
-        os: [ ubuntu-latest, windows-latest, macos-latest ]
-        toolchain: [ "1.65.0", "stable" ]
-    runs-on: ${{ matrix.os }}
-    needs: lint
+        rust: ["1.44.0", "stable"]
    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@master
+      - name: "Install dependencies"
+        run: sudo apt-get install libncurses5-dev
+      - uses: hecrj/setup-rust-action@967aec96c6a27a0ce15c1dac3aaba332d60565e2
        with:
-          toolchain: ${{ matrix.toolchain }}
-      - name: Install cargo-make
-        uses: taiki-e/install-action@cargo-make
+          rust-version: ${{ matrix.rust }}
+          components: rustfmt,clippy
+      - uses: actions/checkout@v1
+      - name: "Get cargo bin directory"
+        id: cargo-bin-dir
+        run: echo "::set-output name=dir::$HOME/.cargo/bin"
+      - name: "Cache cargo make"
+        id: cache-cargo-make
+        uses: actions/cache@v2
+        with:
+          path: ${{ steps.cargo-bin-dir.outputs.dir }}/cargo-make
+          key: ${{ runner.os }}-${{ matrix.rust }}-cargo-make-${{ env.CI_CARGO_MAKE_VERSION }}
+      - name: "Install cargo-make"
+        if: steps.cache-cargo-make.outputs.cache-hit != 'true'
+        run: cargo install cargo-make --version ${{ env.CI_CARGO_MAKE_VERSION }}
+      - name: "Format"
+        run: cargo make fmt
      - name: "Check"
        run: cargo make check
-        env:
-          RUST_BACKTRACE: full
-          CARGO_HUSKY_DONT_INSTALL_HOOKS: true
-
-  clippy:
-    name: Clippy
-    runs-on: ubuntu-latest
-    needs: lint
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          components: clippy
-      - name: Install cargo-make
-        uses: taiki-e/install-action@cargo-make
-      - name: "Clippy"
-        run: cargo make clippy
-        env:
-          RUST_BACKTRACE: full
-          CARGO_HUSKY_DONT_INSTALL_HOOKS: true
-
-  test:
-    strategy:
-      matrix:
-        os: [ ubuntu-latest, windows-latest, macos-latest ]
-        toolchain: [ "1.65.0", "stable" ]
-    runs-on: ${{ matrix.os }}
-    needs: lint
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ matrix.toolchain }}
-      - name: Install cargo-make
-        uses: taiki-e/install-action@cargo-make
      - name: "Test"
        run: cargo make test
        env:
          RUST_BACKTRACE: full
-          CARGO_HUSKY_DONT_INSTALL_HOOKS: true
-
-  lint:
-    runs-on: ubuntu-latest
+      - name: "Clippy"
+        run: cargo make clippy
+  windows:
+    name: Windows
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        rust: ["1.44.0", "stable"]
    steps:
-      - name: Checkout
-        if: github.event_name != 'pull_request'
-        uses: actions/checkout@v3
-      - name: Checkout
-        if: github.event_name == 'pull_request'
-        uses: actions/checkout@v3
+      - uses: actions/checkout@v1
+      - uses: hecrj/setup-rust-action@967aec96c6a27a0ce15c1dac3aaba332d60565e2
        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-      - name: "Check conventional commits"
-        uses: crate-ci/committed@master
+          rust-version: ${{ matrix.rust }}
+          components: rustfmt,clippy
+      - uses: actions/checkout@v1
+      - name: "Get cargo bin directory"
+        id: cargo-bin-dir
+        run: echo "::set-output name=dir::$HOME\.cargo\bin"
+      - name: "Cache cargo make"
+        id: cache-cargo-make
+        uses: actions/cache@v2
        with:
-          args: "-vv"
-          commits: "HEAD"
-      - name: "Check typos"
-        uses: crate-ci/typos@master
-      - name: "Lint dependencies"
-        uses: EmbarkStudios/cargo-deny-action@v1
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@nightly
-        with:
-          components: rustfmt
-      - name: "Formatting"
-        run: cargo fmt --all --check
-
-  coverage:
-    runs-on: ubuntu-latest
-    needs: lint
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install Rust
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          components: llvm-tools
-      - name: cargo install cargo-llvm-cov
-        uses: taiki-e/install-action@cargo-llvm-cov
-      - name: cargo llvm-cov
-        run: cargo llvm-cov --all-features --lcov --output-path lcov.info
+          path: ${{ steps.cargo-bin-dir.outputs.dir }}\cargo-make.exe
+          key: ${{ runner.os }}-${{ matrix.rust }}-cargo-make-${{ env.CI_CARGO_MAKE_VERSION }}
+      - name: "Install cargo-make"
+        if: steps.cache-cargo-make.outputs.cache-hit != 'true'
+        run: cargo install cargo-make --version ${{ env.CI_CARGO_MAKE_VERSION }}
+      - name: "Format"
+        run: cargo make fmt
+      - name: "Check"
+        run: cargo make check
+      - name: "Test"
+        run: cargo make test
        env:
-          CARGO_HUSKY_DONT_INSTALL_HOOKS: true
-      - name: Upload to codecov.io
-        uses: codecov/codecov-action@v3
-        with:
-          fail_ci_if_error: true
+          RUST_BACKTRACE: full
+      - name: "Clippy"
+        run: cargo make clippy
--- a/.markdownlint.yaml
+++ b/.markdownlint.yaml
@@ -1,9 +0,0 @@
-# configuration for https://github.com/DavidAnson/markdownlint
-
-no-inline-html:
-  allowed_elements:
-    - img
-    - details
-    - summary
-line-length:
-  line_length: 100
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,264 +1,6 @@
 # Changelog

-## v0.21.0 - 2023-05-28
-
-### Features
-
- *(backend)* Add termwiz backend and example ([#5](https://github.com/tui-rs-revival/ratatui/issues/5))
- *(block)* Support placing the title on bottom ([#36](https://github.com/tui-rs-revival/ratatui/issues/36))
- *(border)* Add border! macro for easy bitflag manipulation ([#11](https://github.com/tui-rs-revival/ratatui/issues/11))
- *(calendar)* Add calendar widget ([#138](https://github.com/tui-rs-revival/ratatui/issues/138))
- *(color)* Add `FromStr` implementation for `Color` ([#180](https://github.com/tui-rs-revival/ratatui/issues/180))
- *(list)* Add len() to List ([#24](https://github.com/tui-rs-revival/ratatui/pull/24))
- *(paragraph)* Allow Lines to be individually aligned ([#149](https://github.com/tui-rs-revival/ratatui/issues/149))
- *(sparkline)* Finish #1 Sparkline directions PR ([#134](https://github.com/tui-rs-revival/ratatui/issues/134))
- *(terminal)* Add inline viewport ([#114](https://github.com/tui-rs-revival/ratatui/issues/114)) [**breaking**]
- *(test)* Expose test buffer ([#160](https://github.com/tui-rs-revival/ratatui/issues/160))
- *(text)* Add `Masked` to display secure data ([#168](https://github.com/tui-rs-revival/ratatui/issues/168)) [**breaking**]
- *(widget)* Add circle widget ([#159](https://github.com/tui-rs-revival/ratatui/issues/159))
- *(widget)* Add style methods to Span, Spans, Text ([#148](https://github.com/tui-rs-revival/ratatui/issues/148))
- *(widget)* Support adding padding to Block ([#20](https://github.com/tui-rs-revival/ratatui/issues/20))
- *(widget)* Add offset() and offset_mut() for table and list state ([#12](https://github.com/tui-rs-revival/ratatui/issues/12))
-
-### Bug Fixes
-
- *(canvas)* Use full block for Marker::Block ([#133](https://github.com/tui-rs-revival/ratatui/issues/133)) [**breaking**]
- *(example)* Update input in examples to only use press events ([#129](https://github.com/tui-rs-revival/ratatui/issues/129))
- *(uncategorized)* Cleanup doc example ([#145](https://github.com/tui-rs-revival/ratatui/issues/145))
- *(reflow)* Remove debug macro call ([#198](https://github.com/tui-rs-revival/ratatui/issues/198))
-
-### Refactor
-
- *(example)* Remove redundant `vec![]` in `user_input` example ([#26](https://github.com/tui-rs-revival/ratatui/issues/26))
- *(example)* Refactor paragraph example ([#152](https://github.com/tui-rs-revival/ratatui/issues/152))
- *(style)* Mark some Style fns const so they can be defined globally ([#115](https://github.com/tui-rs-revival/ratatui/issues/115))
- *(text)* Replace `Spans` with `Line` ([#178](https://github.com/tui-rs-revival/ratatui/issues/178))
-
-### Documentation
-
- *(apps)* Fix rsadsb/adsb_deku radar link ([#140](https://github.com/tui-rs-revival/ratatui/issues/140))
- *(apps)* Add tenere ([#141](https://github.com/tui-rs-revival/ratatui/issues/141))
- *(apps)* Add twitch-tui ([#124](https://github.com/tui-rs-revival/ratatui/issues/124))
- *(apps)* Add oxycards ([#113](https://github.com/tui-rs-revival/ratatui/issues/113))
- *(apps)* Re-add trippy to APPS.md ([#117](https://github.com/tui-rs-revival/ratatui/issues/117))
- *(block)* Add example for block.inner ([#158](https://github.com/tui-rs-revival/ratatui/issues/158))
- *(changelog)* Update the empty profile link in contributors ([#112](https://github.com/tui-rs-revival/ratatui/issues/112))
- *(readme)* Fix small typo in readme ([#186](https://github.com/tui-rs-revival/ratatui/issues/186))
- *(readme)* Add termwiz demo to examples ([#183](https://github.com/tui-rs-revival/ratatui/issues/183))
- *(readme)* Add acknowledgement section ([#154](https://github.com/tui-rs-revival/ratatui/issues/154))
- *(readme)* Update project description ([#127](https://github.com/tui-rs-revival/ratatui/issues/127))
- *(uncategorized)* Scrape example code from examples/* ([#195](https://github.com/tui-rs-revival/ratatui/issues/195))
-
-### Styling
-
- *(apps)* Update the style of application list ([#184](https://github.com/tui-rs-revival/ratatui/issues/184))
- *(readme)* Update project introduction in README.md ([#153](https://github.com/tui-rs-revival/ratatui/issues/153))
- *(uncategorized)* Clippy's variable inlining in format macros
-
-### Testing
-
- *(buffer)* Add `assert_buffer_eq!` and Debug implementation ([#161](https://github.com/tui-rs-revival/ratatui/issues/161))
- *(list)* Add characterization tests for list ([#167](https://github.com/tui-rs-revival/ratatui/issues/167))
- *(widget)* Add unit tests for Paragraph ([#156](https://github.com/tui-rs-revival/ratatui/issues/156))
-
-### Miscellaneous Tasks
-
- *(uncategorized)* Inline format args ([#190](https://github.com/tui-rs-revival/ratatui/issues/190))
- *(uncategorized)* Minor lints, making Clippy happier ([#189](https://github.com/tui-rs-revival/ratatui/issues/189))
-
-### Build
-
- *(uncategorized)* Bump MSRV to 1.65.0 ([#171](https://github.com/tui-rs-revival/ratatui/issues/171))
-
-### Continuous Integration
-
- *(uncategorized)* Add ci, build, and revert to allowed commit types
-
-### Contributors
-
-Thank you so much to everyone that contributed to this release!
-
-Here is the list of contributors who has contributed to `ratatui` for the first time!
-
- [@kpcyrd](https://github.com/kpcyrd)
- [@fujiapple852](https://github.com/fujiapple852)
- [@BrookJeynes](https://github.com/BrookJeynes)
- [@Ziqi-Yang](https://github.com/Ziqi-Yang)
- [@Xithrius](https://github.com/Xithrius)
- [@lesleyrs](https://github.com/lesleyrs)
- [@pythops](https://github.com/pythops)
- [@wcampbell0x2a](https://github.com/wcampbell0x2a)
- [@sophacles](https://github.com/sophacles)
- [@Eyesonjune18](https://github.com/Eyesonjune18)
- [@a-kenji](https://github.com/a-kenji)
- [@TimerErTim](https://github.com/TimerErTim)
- [@Mehrbod2002](https://github.com/Mehrbod2002)
- [@thomas-mauran](https://github.com/thomas-mauran)
- [@nyurik](https://github.com/nyurik)
-
-## v0.20.1 - 2023-03-19
-
-### Bug Fixes
-
- *(style)* Bold needs a bit ([#104](https://github.com/tui-rs-revival/ratatui/issues/104))
-
-### Documentation
-
- *(apps)* Add "logss" to apps ([#105](https://github.com/tui-rs-revival/ratatui/issues/105))
- *(uncategorized)* Fixup remaining tui references ([#106](https://github.com/tui-rs-revival/ratatui/issues/106))
-
-### Contributors
-
-Thank you so much to everyone that contributed to this release!
-
- [@joshka](https://github.com/joshka)
- [@todoesverso](https://github.com/todoesverso)
- [@UncleScientist](https://github.com/UncleScientist)
-
-## v0.20.0 - 2023-03-19
-
-This marks the first release of `ratatui`, a community-maintained fork of [tui](https://github.com/fdehau/tui-rs).
-
-The purpose of this release is to include **bug fixes** and **small changes** into the repository thus **no new features** are added. We have transferred all the pull requests from the original repository and worked on the low hanging ones to incorporate them in this "maintenance" release.
-
-Here is a list of changes:
-
-### Features
-
- *(cd)* Add continuous deployment workflow ([#93](https://github.com/tui-rs-revival/ratatui/issues/93))
- *(ci)* Add MacOS to CI ([#60](https://github.com/tui-rs-revival/ratatui/issues/60))
- *(widget)* Add `offset()` to `TableState` ([#10](https://github.com/tui-rs-revival/ratatui/issues/10))
- *(widget)* Add `width()` to ListItem ([#17](https://github.com/tui-rs-revival/ratatui/issues/17))
-
-### Bug Fixes
-
- *(ci)* Test MSRV compatibility on CI ([#85](https://github.com/tui-rs-revival/ratatui/issues/85))
- *(ci)* Bump Rust version to 1.63.0 ([#80](https://github.com/tui-rs-revival/ratatui/issues/80))
- *(ci)* Use env for the cargo-make version ([#76](https://github.com/tui-rs-revival/ratatui/issues/76))
- *(ci)* Fix deprecation warnings on CI ([#58](https://github.com/tui-rs-revival/ratatui/issues/58))
- *(doc)* Add 3rd party libraries accidentally removed at #21 ([#61](https://github.com/tui-rs-revival/ratatui/issues/61))
- *(widget)* List should not ignore empty string items ([#42](https://github.com/tui-rs-revival/ratatui/issues/42)) [**breaking**]
- *(uncategorized)* Cassowary/layouts: add extra constraints for fixing Min(v)/Max(v) combination. ([#31](https://github.com/tui-rs-revival/ratatui/issues/31))
- *(uncategorized)* Fix user_input example double key press registered on windows
- *(uncategorized)* Ignore zero-width symbol on rendering `Paragraph`
- *(uncategorized)* Fix typos ([#45](https://github.com/tui-rs-revival/ratatui/issues/45))
- *(uncategorized)* Fix typos ([#47](https://github.com/tui-rs-revival/ratatui/issues/47))
-
-### Refactor
-
- *(style)* Make bitflags smaller ([#13](https://github.com/tui-rs-revival/ratatui/issues/13))
-
-### Documentation
-
- *(apps)* Move 'apps using ratatui' to dedicated file ([#98](https://github.com/tui-rs-revival/ratatui/issues/98)) ([#99](https://github.com/tui-rs-revival/ratatui/issues/99))
- *(canvas)* Add documentation for x_bounds, y_bounds ([#35](https://github.com/tui-rs-revival/ratatui/issues/35))
- *(contributing)* Specify the use of unsafe for optimization ([#67](https://github.com/tui-rs-revival/ratatui/issues/67))
- *(github)* Remove pull request template ([#68](https://github.com/tui-rs-revival/ratatui/issues/68))
- *(readme)* Update crate status badge ([#102](https://github.com/tui-rs-revival/ratatui/issues/102))
- *(readme)* Small edits before first release ([#101](https://github.com/tui-rs-revival/ratatui/issues/101))
- *(readme)* Add install instruction and update title ([#100](https://github.com/tui-rs-revival/ratatui/issues/100))
- *(readme)* Add systeroid to application list ([#92](https://github.com/tui-rs-revival/ratatui/issues/92))
- *(readme)* Add glicol-cli to showcase list ([#95](https://github.com/tui-rs-revival/ratatui/issues/95))
- *(readme)* Add oxker to application list ([#74](https://github.com/tui-rs-revival/ratatui/issues/74))
- *(readme)* Add app kubectl-watch which uses tui ([#73](https://github.com/tui-rs-revival/ratatui/issues/73))
- *(readme)* Add poketex to 'apps using tui' in README ([#64](https://github.com/tui-rs-revival/ratatui/issues/64))
- *(readme)* Update README.md ([#39](https://github.com/tui-rs-revival/ratatui/issues/39))
- *(readme)* Update README.md ([#40](https://github.com/tui-rs-revival/ratatui/issues/40))
- *(readme)* Clarify README.md fork status update
- *(uncategorized)* Fix: fix typos ([#90](https://github.com/tui-rs-revival/ratatui/issues/90))
- *(uncategorized)* Update to build more backends ([#81](https://github.com/tui-rs-revival/ratatui/issues/81))
- *(uncategorized)* Expand "Apps" and "Third-party" sections ([#21](https://github.com/tui-rs-revival/ratatui/issues/21))
- *(uncategorized)* Add tui-input and update xplr in README.md
- *(uncategorized)* Add hncli to list of applications made with tui-rs ([#41](https://github.com/tui-rs-revival/ratatui/issues/41))
- *(uncategorized)* Updated readme and contributing guide with updates about the fork ([#46](https://github.com/tui-rs-revival/ratatui/issues/46))
-
-### Performance
-
- *(layout)* Better safe shared layout cache ([#62](https://github.com/tui-rs-revival/ratatui/issues/62))
-
-### Miscellaneous Tasks
-
- *(cargo)* Update project metadata ([#94](https://github.com/tui-rs-revival/ratatui/issues/94))
- *(ci)* Integrate `typos` for checking typos ([#91](https://github.com/tui-rs-revival/ratatui/issues/91))
- *(ci)* Change the target branch to main ([#79](https://github.com/tui-rs-revival/ratatui/issues/79))
- *(ci)* Re-enable clippy on CI ([#59](https://github.com/tui-rs-revival/ratatui/issues/59))
- *(uncategorized)* Integrate `committed` for checking conventional commits ([#77](https://github.com/tui-rs-revival/ratatui/issues/77))
- *(uncategorized)* Update `rust-version` to 1.59 in Cargo.toml ([#57](https://github.com/tui-rs-revival/ratatui/issues/57))
- *(uncategorized)* Update deps ([#51](https://github.com/tui-rs-revival/ratatui/issues/51))
- *(uncategorized)* Fix typo in layout.rs ([#619](https://github.com/tui-rs-revival/ratatui/issues/619))
- *(uncategorized)* Add apps using `tui`
-
-### Contributors
-
-Thank you so much to everyone that contributed to this release!
-
- [@orhun](https://github.com/orhun)
- [@mindoodoo](https://github.com/mindoodoo)
- [@sayanarijit](https://github.com/sayanarijit)
- [@Owletti](https://github.com/Owletti)
- [@UncleScientist](https://github.com/UncleScientist)
- [@rhysd](https://github.com/rhysd)
- [@ckaznable](https://github.com/ckaznable)
- [@imuxin](https://github.com/imuxin)
- [@mrjackwills](https://github.com/mrjackwills)
- [@conradludgate](https://github.com/conradludgate)
- [@kianmeng](https://github.com/kianmeng)
- [@chaosprint](https://github.com/chaosprint)
-
-And most importantly, special thanks to [Florian Dehau](https://github.com/fdehau) for creating this awesome library 💖 We look forward to building on the strong foundations that the original crate laid out.
-
-## v0.19.0 - 2022-08-14
-
-### Features
-
-* Bump `crossterm` to `0.25`
-
-## v0.18.0 - 2022-04-24
-
-### Features
-
-* Update `crossterm` to `0.23`
-
-## v0.17.0 - 2022-01-22
-
-### Features
-
-* Add option to `widgets::List` to repeat the highlight symbol for each line of multi-line items (#533).
-* Add option to control the alignment of `Axis` labels in the `Chart` widget (#568).
-
-### Breaking changes
-
-* The minimum supported rust version is now `1.56.1`.
-
-#### New default backend and consolidated backend options (#553)
-
-* `crossterm` is now the default backend.
-If you are already using the `crossterm` backend, you can simplify your dependency specification in `Cargo.toml`:
-```diff
- tui = { version = "0.16", default-features = false, features = ["crossterm"] }
-+ tui = "0.17"
-```
-If you are using the `termion` backend, your `Cargo` is now a bit more verbose:
-```diff
- tui = "0.16"
-+ tui = { version = "0.17", default-features = false, features = ["termion"] }
-```
-
-`crossterm` has also been bumped to version `0.22`.
-
-Because of their apparent low usage, `curses` and `rustbox` backends have been removed.
-If you are using one of them, you can import their last implementation in your own project:
-* [curses](https://github.com/fdehau/tui-rs/blob/v0.16.0/src/backend/curses.rs)
-* [rustbox](https://github.com/fdehau/tui-rs/blob/v0.16.0/src/backend/rustbox.rs)
-
-#### Canvas labels (#543)
-
-* Labels of the `Canvas` widget are now `text::Spans`.
-The signature of `widgets::canvas::Context::print` has thus been updated:
-```diff
- ctx.print(x, y, "Some text", Color::Yellow);
-+ ctx.print(x, y, Span::styled("Some text", Style::default().fg(Color::Yellow)))
-```
+## To be released

 ## v0.16.0 - 2021-08-01

@@ -481,7 +223,7 @@ In this new release, you may now write this as:
 ```rust
 Block::default()
    .style(Style::default().bg(Color::Green))
-    // The style is not overridden anymore, we simply add new style rule for the title.
+    // The style is not overidden anymore, we simply add new style rule for the title.
    .title(Span::styled("My title", Style::default().add_modifier(Modifier::BOLD)))
 ```

@@ -489,9 +231,9 @@ In addition, the crate now provides a method `patch` to combine two styles into
 rules:

 ```rust
-let style = Style::default().modifier(Modifier::BOLD);
+let style = Style::default().modifer(Modifier::BOLD);
 let style = style.patch(Style::default().add_modifier(Modifier::ITALIC));
-// style.modifier == Modifier::BOLD | Modifier::ITALIC, the modifier has been enriched not overridden
+// style.modifer == Modifier::BOLD | Modifier::ITALIC, the modifier has been enriched not overidden
 ```

 - `Style::modifier` has been removed in favor of `Style::add_modifier` and `Style::remove_modifier`.
@@ -809,7 +551,7 @@ let style = Style::default().add_modifier(Modifier::ITALIC | Modifier::BOLD);

 ### Bug Fixes

-* Ensure correct behavior of the alternate screens with the `Crossterm` backend.
+* Ensure correct behavoir of the alternate screens with the `Crossterm` backend.
 * Fix out of bounds panic when two `Buffer` are merged.

 ## v0.4.0 - 2019-02-03
@@ -878,7 +620,7 @@ additional `termion` features.

 * Replace `Item` by a generic and flexible `Text` that can be used in both
 `Paragraph` and `List` widgets.
-* Remove unnecessary borrows on `Style`.
+* Remove unecessary borrows on `Style`.

 ## v0.3.0-beta.0 - 2018-09-04

@@ -901,7 +643,7 @@ widgets on the given `Frame`
 * All widgets use the consumable builder pattern
 * `SelectableList` can have no selected item and the highlight symbol is hidden
 in this case
-* Remove markup language inside `Paragraph`. `Paragraph` now expects an iterator
+* Remove markup langage inside `Paragraph`. `Paragraph` now expects an iterator
 of `Text` items

 ## v0.2.3 - 2018-06-09
@@ -909,7 +651,7 @@ of `Text` items
 ### Features

 * Add `start_corner` option for `List`
-* Add more text alignment options for `Paragraph`
+* Add more text aligment options for `Paragraph`

 ## v0.2.2 - 2018-05-06

--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,38 +1,10 @@
-# Fork Status
-
-## Pull Requests
-
-**All** pull requests opened on the original repository have been imported. We'll be going through any open PRs in a timely manner, starting with the **smallest bug fixes and README updates**. If you have an open PR make sure to let us know about it on our [discord](https://discord.gg/pMCEU9hNEj) as it helps to know you are still active.
-
-## Issues
-
-We have been unsuccessful in importing all issues opened on the previous repository.
-For that reason, anyone wanting to **work on or discuss** an issue will have to follow the following workflow :
-
- Recreate the issue
- Start by referencing the **original issue**: ```Referencing issue #[<issue number>](<original issue link>)```
- Then, paste the original issues **opening** text
-
-You can then resume the conversation by replying to this new issue you have created.
-
-### Closing Issues
-
-If you close an issue that you have "imported" to this fork, please make sure that you add the issue to the **CLOSED_ISSUES.md**. This will enable us to keep track of which issues have been closed from the original repo, in case we are able to have the original repository transferred.
-
 # Contributing

-## Implementation Guidelines
-
-### Use of unsafe for optimization purposes
-
-**Do not** use unsafe to achieve better performances. This is subject to change, [see.](https://github.com/tui-rs-revival/tui-rs-revival/discussions/66)
-The only exception to this rule is if it's to fix **reproducible slowness.**
-
 ## Building

 [cargo-make]: https://github.com/sagiegurari/cargo-make "cargo-make"

-`ratatui` is an ordinary Rust project where common tasks are managed with [cargo-make].
+`tui` is an ordinary Rust project where common tasks are managed with [cargo-make].
 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`.

@@ -43,14 +15,6 @@ Please include as many details as possible in your PR description to help the re
 Make sure to highlight changes 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.

-## Committing
-
-To avoid any issues that may arrise with the CI/CD by not following the [conventional commit](https://www.conventionalcommits.org/en/v1.0.0/) syntax, we recommend to install [Commitizen](https://commitizen-tools.github.io/commitizen/).\
-By using this tool you automatically follow the configuration defined in [.cz.toml](.cz.toml).
-
-Additionally, we're using [cargo-husky](https://github.com/rhysd/cargo-husky) to automatically load pre-push hook, which will run `cargo make ci` before each push. It will load the hook automatically when you run `cargo test`. If `cargo-make` is not installed, it will install it for you.\
-This will ensure that your code is formatted, compiles and passes all tests before you push. If you want to skip this check, you can use `git push --no-verify`.
-
 ## Continuous Integration

 We use Github Actions for the CI where we perform the following checks:
@@ -64,6 +28,6 @@ You can also check most of those things yourself locally using `cargo make ci` w
 ## Tests

 The test coverage of the crate is far from being ideal but we already have a fair amount of tests in place.
-Beside the usual doc and unit tests, one of the most valuable test you can write for `ratatui` is a test against the `TestBackend`.
+Beside the usual doc and unit tests, one of the most valuable test you can write for `tui` is a test again 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.
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,165 +1,127 @@
 [package]
-name = "ratatui"
-version = "0.21.0"
+name = "tui"
+version = "0.16.0"
 authors = ["Florian Dehau <work@fdehau.com>"]
-description = "A library to build rich terminal user interfaces or dashboards"
-documentation = "https://docs.rs/ratatui/latest/ratatui/"
+description = """
+A library to build rich terminal user interfaces or dashboards
+"""
+documentation = "https://docs.rs/tui/0.16.0/tui/"
 keywords = ["tui", "terminal", "dashboard"]
-repository = "https://github.com/tui-rs-revival/ratatui"
+repository = "https://github.com/fdehau/tui-rs"
 readme = "README.md"
 license = "MIT"
-exclude = [
-  "assets/*",
-  ".github",
-  "Makefile.toml",
-  "CONTRIBUTING.md",
-  "*.log",
-  "tags",
-]
+exclude = ["assets/*", ".github", "Makefile.toml", "CONTRIBUTING.md", "*.log", "tags"]
 autoexamples = true
-edition = "2021"
-rust-version = "1.65.0"
+edition = "2018"

 [badges]

 [features]
-default = ["crossterm"]
-all-widgets = ["widget-calendar"]
-widget-calendar = ["time"]
-macros = []
-serde = ["dep:serde", "bitflags/serde"]
-
-[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"]
+default = ["termion"]
+curses = ["easycurses", "pancurses"]

 [dependencies]
-bitflags = "2.3"
+bitflags = "1.0"
 cassowary = "0.3"
-crossterm = { version = "0.26", optional = true }
-indoc = "2.0"
-serde = { version = "1", optional = true, features = ["derive"] }
-termion = { version = "2.0", optional = true }
-termwiz = { version = "0.20.0", optional = true }
-time = { version = "0.3.11", optional = true, features = ["local-offset"] }
-unicode-segmentation = "1.10"
+unicode-segmentation = "1.2"
 unicode-width = "0.1"
+termion = { version = "1.5", optional = true }
+rustbox = { version = "0.11", optional = true }
+crossterm = { version = "0.20", optional = true }
+easycurses = { version = "0.12.2", optional = true }
+pancurses = { version = "0.16.1", optional = true, features = ["win32a"] }
+serde = { version = "1", "optional" = true, features = ["derive"]}

 [dev-dependencies]
-anyhow = "1.0.71"
-argh = "0.1"
-cargo-husky = { version = "1.5.0", default-features = false, features = ["user-hooks"] }
-criterion = { version = "0.5", features = ["html_reports"] }
-fakeit = "1.1"
 rand = "0.8"
-
-[[bench]]
-name = "paragraph"
-harness = false
-
-[[example]]
-name = "barchart"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "block"
-required-features = ["crossterm"]
-doc-scrape-examples = true
+argh = "0.1"

 [[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 = "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 = "filter"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "gauge"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "hello_world"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "inline"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "layout"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[example]]
-name = "list"
-required-features = ["crossterm"]
-doc-scrape-examples = true
-
-[[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 = "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
+path = "examples/canvas.rs"
+required-features = ["termion"]

 [[example]]
 name = "user_input"
+path = "examples/user_input.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "gauge"
+path = "examples/gauge.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "barchart"
+path = "examples/barchart.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "chart"
+path = "examples/chart.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "paragraph"
+path = "examples/paragraph.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "list"
+path = "examples/list.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "table"
+path = "examples/table.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "tabs"
+path = "examples/tabs.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "custom_widget"
+path = "examples/custom_widget.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "layout"
+path = "examples/layout.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "popup"
+path = "examples/popup.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "block"
+path = "examples/block.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "sparkline"
+path = "examples/sparkline.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "termion_demo"
+path = "examples/termion_demo.rs"
+required-features = ["termion"]
+
+[[example]]
+name = "rustbox_demo"
+path = "examples/rustbox_demo.rs"
+required-features = ["rustbox"]
+
+[[example]]
+name = "crossterm_demo"
+path = "examples/crossterm_demo.rs"
 required-features = ["crossterm"]
-doc-scrape-examples = true
+
+[[example]]
+name = "curses_demo"
+path = "examples/curses_demo.rs"
+required-features = ["curses"]
--- a/Makefile.toml
+++ b/Makefile.toml
@@ -1,90 +1,40 @@
-# configuration for https://github.com/sagiegurari/cargo-make
-
 [config]
 skip_core_tasks = true

+[env.TUI_FEATURES]
+source = "${CARGO_MAKE_RUST_TARGET_OS}"
+default_value = "unknown"
+
+[env.TUI_FEATURES.mapping]
+linux = "serde,crossterm,termion,rustbox,curses"
+macos = "serde,crossterm,termion,rustbox,curses"
+windows = "serde,crossterm"
+
+[tasks.default]
+dependencies = [
+  "check",
+]
+
 [tasks.ci]
-run_task = [
-  { name = "ci-unix", condition = { platforms = [
-    "linux",
-    "mac",
-  ] } },
-  { name = "ci-windows", condition = { platforms = [
-    "windows",
-  ] } },
-]
-
-[tasks.ci-unix]
-private = true
 dependencies = [
-  "style-check",
-  "check-unix",
-  "test-unix",
-  "clippy-unix",
+  "fmt",
+  "check",
+  "test",
+  "clippy",
 ]

-[tasks.ci-windows]
-private = true
-dependencies = [
-  "style-check",
-  "check-windows",
-  "test-windows",
-  "clippy-windows",
-]
-
-[tasks.style-check]
-dependencies = ["fmt", "typos"]

 [tasks.fmt]
-toolchain = "nightly"
 command = "cargo"
-args = ["fmt", "--all", "--check"]
-
-[tasks.typos]
-install_crate = { crate_name = "typos-cli", binary = "typos", test_arg = "--version" }
-command = "typos"
+args = [
+  "fmt",
+  "--all",
+  "--",
+  "--check",
+]

 [tasks.check]
-run_task = [
-  { name = "check-unix", condition = { platforms = [
-    "linux",
-    "mac",
-  ] } },
-  { name = "check-windows", condition = { platforms = [
-    "windows",
-  ] } },
-]
-
-[tasks.check-unix]
-private = true
-dependencies = [
-  "check-crossterm",
-  "check-termion",
-  "check-termwiz",
-]
-
-[tasks.check-windows]
-private = true
-dependencies = [
-  "check-crossterm",
-  "check-termwiz",
-]
-
-[tasks.check-crossterm]
-env = { TUI_FEATURES = "serde,crossterm" }
-run_task = "check-backend"
-
-[tasks.check-termion]
-env = { TUI_FEATURES = "serde,termion" }
-run_task = "check-backend"
-
-[tasks.check-termwiz]
-env = { TUI_FEATURES = "serde,termwiz" }
-run_task = "check-backend"
-
-[tasks.check-backend]
 command = "cargo"
-condition = { env_set = ["TUI_FEATURES"] }
 args = [
  "check",
  "--no-default-features",
@@ -94,46 +44,7 @@ args = [
 ]

 [tasks.build]
-run_task = [
-  { name = "build-unix", condition = { platforms = [
-    "linux",
-    "mac",
-  ] } },
-  { name = "build-windows", condition = { platforms = [
-    "windows",
-  ] } },
-]
-
-[tasks.build-unix]
-private = true
-dependencies = [
-  "build-crossterm",
-  "build-termion",
-  "build-termwiz",
-]
-
-[tasks.build-windows]
-private = true
-dependencies = [
-  "build-crossterm",
-  "build-termwiz",
-]
-
-[tasks.build-crossterm]
-env = { TUI_FEATURES = "serde,crossterm" }
-run_task = "build-backend"
-
-[tasks.build-termion]
-env = { TUI_FEATURES = "serde,termion" }
-run_task = "build-backend"
-
-[tasks.build-termwiz]
-env = { TUI_FEATURES = "serde,termwiz" }
-run_task = "build-backend"
-
-[tasks.build-backend]
 command = "cargo"
-condition = { env_set = ["TUI_FEATURES"] }
 args = [
  "build",
  "--no-default-features",
@@ -143,52 +54,10 @@ args = [
 ]

 [tasks.clippy]
-run_task = [
-  { name = "clippy-unix", condition = { platforms = [
-    "linux",
-    "mac",
-  ] } },
-  { name = "clippy-windows", condition = { platforms = [
-    "windows",
-  ] } },
-]
-
-[tasks.clippy-unix]
-private = true
-dependencies = [
-  "clippy-crossterm",
-  "clippy-termion",
-  "clippy-termwiz",
-]
-
-[tasks.clippy-windows]
-private = true
-dependencies = [
-  "clippy-crossterm",
-  "clippy-termwiz",
-]
-
-[tasks.clippy-crossterm]
-env = { TUI_FEATURES = "serde,crossterm" }
-run_task = "clippy-backend"
-
-[tasks.clippy-termion]
-env = { TUI_FEATURES = "serde,termion" }
-run_task = "clippy-backend"
-
-[tasks.clippy-termwiz]
-env = { TUI_FEATURES = "serde,termwiz" }
-run_task = "clippy-backend"
-
-[tasks.clippy-backend]
 command = "cargo"
-condition = { env_set = ["TUI_FEATURES"] }
 args = [
  "clippy",
-  "--all-targets",
  "--no-default-features",
-  "--tests",
-  "--benches",
  "--features",
  "${TUI_FEATURES}",
  "--",
@@ -197,69 +66,67 @@ args = [
 ]

 [tasks.test]
-run_task = [
-  { name = "test-unix", condition = { platforms = [
-    "linux",
-    "mac",
-  ] } },
-  { name = "test-windows", condition = { platforms = [
-    "windows",
-  ] } },
-]
+linux_alias = "test-unix"
+mac_alias = "test-unix"
+windows_alias = "test-windows"

 [tasks.test-unix]
-private = true
-dependencies = [
-  "test-crossterm",
-  "test-termion",
-  "test-termwiz",
-  "test-doc",
-]
-
-[tasks.test-windows]
-private = true
-dependencies = [
-  "test-crossterm",
-  "test-termwiz",
-  "test-doc",
-]
-
-[tasks.test-crossterm]
-env = { TUI_FEATURES = "serde,crossterm,all-widgets,macros" }
-run_task = "test-backend"
-
-[tasks.test-termion]
-env = { TUI_FEATURES = "serde,termion,all-widgets,macros" }
-run_task = "test-backend"
-
-[tasks.test-termwiz]
-env = { TUI_FEATURES = "serde,termwiz,all-widgets,macros" }
-run_task = "test-backend"
-
-[tasks.test-backend]
 command = "cargo"
-condition = { env_set = ["TUI_FEATURES"] }
+args = [
+  "test",
+  "--no-default-features",
+  "--features",
+  "${TUI_FEATURES}"
+]
+
+# Documentation tests cannot be run on Windows for now
+[tasks.test-windows]
+command = "cargo"
 args = [
  "test",
  "--no-default-features",
  "--features",
  "${TUI_FEATURES}",
-  "--all-targets",
+  "--lib",
+  "--tests",
+  "--examples",
 ]

-[tasks.test-doc]
-command = "cargo"
-args = ["test", "--doc"]
-
 [tasks.run-example]
 private = true
-condition = { env_set = ["TUI_EXAMPLE_NAME"] }
+condition = { env_set = ["TUI_EXAMPLE_NAME", "TUI_FEATURES"] }
 command = "cargo"
-args = ["run", "--release", "--example", "${TUI_EXAMPLE_NAME}"]
+args = [
+    "run",
+    "--features",
+    "${TUI_FEATURES}",
+    "--release",
+    "--example",
+    "${TUI_EXAMPLE_NAME}"
+]
+
+[tasks.run-example-windows]
+private = true
+condition = { env = {"TUI_EXAMPLE_NAME" = "crossterm_demo"} }
+run_task = "run-example"
+
+[tasks.run-example-router]
+private = true
+run_task = [
+    { name = "run-example-windows", condition = { platforms = ["window"] } },
+    { name = "run-example" }
+]

 [tasks.build-examples]
+condition = { env_set = ["TUI_FEATURES"] }
 command = "cargo"
-args = ["build", "--examples", "--release"]
+args = [
+    "build",
+    "--examples",
+    "--features",
+    "${TUI_FEATURES}",
+    "--release"
+]

 [tasks.run-examples]
 dependencies = ["build-examples"]
@@ -270,6 +137,6 @@ for file in ${files}
  name = basename ${file}
  name = substring ${name} -3
  set_env TUI_EXAMPLE_NAME ${name}
-  cm_run_task run-example
+  cm_run_task run-example-router
 end
 '''
--- a/README.md
+++ b/README.md
@@ -1,263 +1,127 @@
-# Ratatui
+# tui-rs

-<img align="left" src="https://avatars.githubusercontent.com/u/125200832?s=128&v=4">
+[![Build Status](https://github.com/fdehau/tui-rs/workflows/CI/badge.svg)](https://github.com/fdehau/tui-rs/actions?query=workflow%3ACI+)
+[![Crate Status](https://img.shields.io/crates/v/tui.svg)](https://crates.io/crates/tui)
+[![Docs Status](https://docs.rs/tui/badge.svg)](https://docs.rs/crate/tui/)

-`ratatui` is a [Rust](https://www.rust-lang.org) library to build rich terminal user interfaces and
-dashboards. It is a community fork of the original [tui-rs](https://github.com/fdehau/tui-rs)
-project.
+<img src="./assets/demo.gif" alt="Demo cast under Linux Termite with Inconsolata font 12pt">

-[![Crates.io](https://img.shields.io/crates/v/ratatui?logo=rust&style=for-the-badge)](https://crates.io/crates/ratatui)
-[![License](https://img.shields.io/crates/l/ratatui?style=for-the-badge)](./LICENSE) [![GitHub CI
-Status](https://img.shields.io/github/actions/workflow/status/tui-rs-revival/ratatui/ci.yml?style=for-the-badge&logo=github)](https://github.com/tui-rs-revival/ratatui/actions?query=workflow%3ACI+)
-[![Docs.rs](https://img.shields.io/docsrs/ratatui?logo=rust&style=for-the-badge)](https://docs.rs/crate/ratatui/)
-[![Dependency
-Status](https://deps.rs/repo/github/tui-rs-revival/ratatui/status.svg?style=for-the-badge)](https://deps.rs/repo/github/tui-rs-revival/ratatui)
-[![Codecov](https://img.shields.io/codecov/c/github/tui-rs-revival/ratatui?logo=codecov&style=for-the-badge&token=BAQ8SOKEST)](https://app.codecov.io/gh/tui-rs-revival/ratatui)
-[![Discord](https://img.shields.io/discord/1070692720437383208?label=discord&logo=discord&style=for-the-badge)](https://discord.gg/pMCEU9hNEj)
+`tui-rs` is a [Rust](https://www.rust-lang.org) library to build rich terminal
+user interfaces and dashboards. It is heavily inspired by the `Javascript`
+library [blessed-contrib](https://github.com/yaronn/blessed-contrib) and the
+`Go` library [termui](https://github.com/gizak/termui).

-<!-- See RELEASE.md for instructions on creating the demo gif --->
-![Demo of Ratatui](https://github.com/tui-rs-revival/ratatui/assets/24392180/93ab0e38-93e0-4ae0-a31b-91ae6c393185)
+The library itself supports four different backends to draw to the terminal. You
+can either choose from:

-<details>
-<summary>Table of Contents</summary>
+  - [termion](https://github.com/ticki/termion)
+  - [rustbox](https://github.com/gchp/rustbox)
+  - [crossterm](https://github.com/crossterm-rs/crossterm)
+  - [pancurses](https://github.com/ihalila/pancurses)

-* [Ratatui](#ratatui)
-  * [Installation](#installation)
-  * [Introduction](#introduction)
-  * [Quickstart](#quickstart)
-  * [Status of this fork](#status-of-this-fork)
-  * [Rust version requirements](#rust-version-requirements)
-  * [Documentation](#documentation)
-  * [Examples](#examples)
-  * [Widgets](#widgets)
-    * [Built in](#built-in)
-    * [Third\-party libraries, bootstrapping templates and
-      widgets](#third-party-libraries-bootstrapping-templates-and-widgets)
-  * [Apps](#apps)
-  * [Alternatives](#alternatives)
-  * [Contributors](#contributors)
-  * [Acknowledgments](#acknowledgments)
-  * [License](#license)
+However, some features may only be available in one of the four.

-</details>
+The library is based on the principle of immediate rendering with intermediate
+buffers. This means that at each new frame you should build all widgets that are
+supposed to be part of the UI. While providing a great flexibility for rich and
+interactive UI, this may introduce overhead for highly dynamic content. So, the
+implementation try to minimize the number of ansi escapes sequences generated to
+draw the updated UI. In practice, given the speed of `Rust` the overhead rather
+comes from the terminal emulator than the library itself.

-## Installation
+Moreover, the library does not provide any input handling nor any event system and
+you may rely on the previously cited libraries to achieve such features.

-```shell
-cargo add ratatui --features all-widgets
+### Rust version requirements
+
+Since version 0.10.0, `tui` requires **rustc version 1.44.0 or greater**.
+
+### [Documentation](https://docs.rs/tui)
+
+### Demo
+
+The demo shown in the gif can be run with all available backends
+(`examples/*_demo.rs` files). For example to see the `termion` version one could
+run:
+
+```
+cargo run --example termion_demo --release -- --tick-rate 200
 ```

-Or modify your `Cargo.toml`
+where `tick-rate` is the UI refresh rate in ms.

-```toml
-[dependencies]
-ratatui = { version = "0.21.0", features = ["all-widgets"]}
+The UI code is in [examples/demo/ui.rs](https://github.com/fdehau/tui-rs/blob/v0.16.0/examples/demo/ui.rs) while the
+application state is in [examples/demo/app.rs](https://github.com/fdehau/tui-rs/blob/v0.16.0/examples/demo/app.rs).
+
+Beware that the `termion_demo` only works on Unix platforms. If you are a Windows user,
+you can see the same demo using the `crossterm` backend with the following command:
+
+```
+cargo run --example crossterm_demo --no-default-features --features="crossterm" --release -- --tick-rate 200
 ```

-Ratatui is mostly backwards compatible with `tui-rs`. To migrate an existing project, it may be
-easier to rename the ratatui dependency to `tui` rather than updating every usage of the crate.
-E.g.:
+If the user interface contains glyphs that are not displayed correctly by your terminal, you may want to run
+the demo without those symbols:

-```toml
-[dependencies]
-tui = { package = "ratatui", version = "0.21.0", features = ["all-widgets"]}
+```
+cargo run --example crossterm_demo --no-default-features --features="crossterm" --release -- --tick-rate 200 --enhanced-graphics false
 ```

-## Introduction
+### Widgets

-`ratatui` is a terminal UI library that supports multiple backends:
+The library comes with the following list of widgets:

-* [crossterm](https://github.com/crossterm-rs/crossterm) [default]
-* [termion](https://github.com/ticki/termion)
-* [termwiz](https://github.com/wez/wezterm/tree/master/termwiz)
+  * [Block](https://github.com/fdehau/tui-rs/blob/v0.16.0/examples/block.rs)
+  * [Gauge](https://github.com/fdehau/tui-rs/blob/v0.16.0/examples/gauge.rs)
+  * [Sparkline](https://github.com/fdehau/tui-rs/blob/v0.16.0/examples/sparkline.rs)
+  * [Chart](https://github.com/fdehau/tui-rs/blob/v0.16.0/examples/chart.rs)
+  * [BarChart](https://github.com/fdehau/tui-rs/blob/v0.16.0/examples/barchart.rs)
+  * [List](https://github.com/fdehau/tui-rs/blob/v0.16.0/examples/list.rs)
+  * [Table](https://github.com/fdehau/tui-rs/blob/v0.16.0/examples/table.rs)
+  * [Paragraph](https://github.com/fdehau/tui-rs/blob/v0.16.0/examples/paragraph.rs)
+  * [Canvas (with line, point cloud, map)](https://github.com/fdehau/tui-rs/blob/v0.16.0/examples/canvas.rs)
+  * [Tabs](https://github.com/fdehau/tui-rs/blob/v0.16.0/examples/tabs.rs)

-The library is based on the principle of immediate rendering with intermediate buffers. This means
-that at each new frame you should build all widgets that are supposed to be part of the UI. While
-providing a great flexibility for rich and interactive UI, this may introduce overhead for highly
-dynamic content. So, the implementation try to minimize the number of ansi escapes sequences
-generated to draw the updated UI. In practice, given the speed of `Rust` the overhead rather comes
-from the terminal emulator than the library itself.
+Click on each item to see the source of the example. Run the examples with with 
+cargo (e.g. to run the demo `cargo run --example demo`), and quit by pressing `q`.

-Moreover, the library does not provide any input handling nor any event system and you may rely on
-the previously cited libraries to achieve such features.
+You can run all examples by running `make run-examples`.

-We keep a [CHANGELOG](./CHANGELOG.md) generated by [git-cliff](https://github.com/orhun/git-cliff)
-utilizing [Conventional Commits](https://www.conventionalcommits.org/).
+### Third-party widgets

-## Quickstart
+* [tui-logger](https://github.com/gin66/tui-logger)

-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
-[hello_world.rs](./examples/hello_world.rs). For more guidance on how to create Ratatui apps, see
-the [Docs](https://docs.rs/ratatui) and [Examples](#examples). There is also a starter template
-available at [rust-tui-template](https://github.com/tui-rs-revival/rust-tui-template).
+### Apps using tui

-```rust
-fn main() -> Result<(), Box<dyn Error>> {
-    let mut terminal = setup_terminal()?;
-    run(&mut terminal)?;
-    restore_terminal(&mut terminal)?;
-    Ok(())
-}
+* [spotify-tui](https://github.com/Rigellute/spotify-tui)
+* [bandwhich](https://github.com/imsnif/bandwhich)
+* [kmon](https://github.com/orhun/kmon)
+* [gpg-tui](https://github.com/orhun/gpg-tui)
+* [ytop](https://github.com/cjbassi/ytop)
+* [zenith](https://github.com/bvaisvil/zenith)
+* [bottom](https://github.com/ClementTsang/bottom)
+* [oha](https://github.com/hatoo/oha)
+* [gitui](https://github.com/extrawurst/gitui)
+* [rust-sadari-cli](https://github.com/24seconds/rust-sadari-cli)
+* [desed](https://github.com/SoptikHa2/desed)
+* [diskonaut](https://github.com/imsnif/diskonaut)
+* [tickrs](https://github.com/tarkah/tickrs)
+* [rusty-krab-manager](https://github.com/aryakaul/rusty-krab-manager)
+* [termchat](https://github.com/lemunozm/termchat)
+* [taskwarrior-tui](https://github.com/kdheepak/taskwarrior-tui)
+* [gping](https://github.com/orf/gping/)
+* [Vector](https://vector.dev)
+* [KDash](https://github.com/kdash-rs/kdash)
+* [xplr](https://github.com/sayanarijit/xplr)
+* [minesweep](https://github.com/cpcloud/minesweep-rs)
+* [Battleship.rs](https://github.com/deepu105/battleship-rs)
+* [termscp](https://github.com/veeso/termscp)

-fn setup_terminal() -> Result<Terminal<CrosstermBackend<Stdout>>, Box<dyn Error>> {
-    let mut stdout = io::stdout();
-    enable_raw_mode()?;
-    execute!(stdout, EnterAlternateScreen)?;
-    Ok(Terminal::new(CrosstermBackend::new(stdout))?)
-}
+### Alternatives

-fn restore_terminal(
-    terminal: &mut Terminal<CrosstermBackend<Stdout>>,
-) -> Result<(), Box<dyn Error>> {
-    disable_raw_mode()?;
-    execute!(terminal.backend_mut(), LeaveAlternateScreen,)?;
-    Ok(terminal.show_cursor()?)
-}
-
-fn run(terminal: &mut Terminal<CrosstermBackend<Stdout>>) -> Result<(), Box<dyn Error>> {
-    Ok(loop {
-        terminal.draw(|frame| {
-            let greeting = Paragraph::new("Hello World!");
-            frame.render_widget(greeting, frame.size());
-        })?;
-        if event::poll(Duration::from_millis(250))? {
-            if let Event::Key(key) = event::read()? {
-                if KeyCode::Char('q') == key.code {
-                    break;
-                }
-            }
-        }
-    })
-}
-```
-
-## 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 are also plans to implement a [Matrix](https://matrix.org/)
-bridge in the near future. **Discord is not a MUST to contribute**. We follow a pretty standard
-github centered open source workflow keeping the most important conversations on GitHub, open an
-issue or PR and it will be addressed. 😄
-
-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.21.0, The Minimum Supported Rust Version (MSRV) of `ratatui` is 1.65.0.
-
-## Documentation
-
-The documentation can be found on [docs.rs.](https://docs.rs/ratatui)
-
-## Examples
-
-The demo shown in the gif above is available on all available backends.
-
-```shell
-# crossterm
-cargo run --example demo
-# termion
-cargo run --example demo --no-default-features --features=termion
-# termwiz
-cargo run --example demo --no-default-features --features=termwiz
-```
-
-The UI code for the is in [examples/demo/ui.rs](./examples/demo/ui.rs) while the application state
-is in [examples/demo/app.rs](./examples/demo/app.rs).
-
-If the user interface contains glyphs that are not displayed correctly by your terminal, you may
-want to run the demo without those symbols:
-
-```shell
-cargo run --example demo --release -- --tick-rate 200 --enhanced-graphics false
-```
-
-More examples are available in the [examples](./examples/) folder.
-
-## Widgets
-
-### Built in
-
-The library comes with the following
-[widgets](https://docs.rs/ratatui/latest/ratatui/widgets/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)
-* [BarChart](https://docs.rs/ratatui/latest/ratatui/widgets/struct.BarChart.html)
-* [Block](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Block.html)
-* [Calendar](https://docs.rs/ratatui/latest/ratatui/widgets/calendar/index.html)
-* [Chart](https://docs.rs/ratatui/latest/ratatui/widgets/struct.Chart.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)
-* [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 wiget has an associated example which can be found in the [examples](./examples/) folder. Run
-each examples 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
-  `tui::text::Text`
-* [color-to-tui](https://github.com/uttarayan21/color-to-tui) — Parse hex colors to
-  `tui::style::Color`
-* [rust-tui-template](https://github.com/orhun/rust-tui-template) — A template for bootstrapping a
-  Rust TUI application with Tui-rs & crossterm
-* [simple-tui-rs](https://github.com/pmsanford/simple-tui-rs) — A simple example tui-rs app
-* [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 the list of more than 50 [Apps using
-`Ratatui`](https://github.com/tui-rs-revival/ratatui/wiki/Apps-using-Ratatui)!
-
-## Alternatives
-
-You might want to checkout [Cursive](https://github.com/gyscos/Cursive) for an alternative solution
-to build text user interfaces in Rust.
-
-## Contributors
-
-[![GitHub
-Contributors](https://contrib.rocks/image?repo=tui-rs-revival/ratatui)](https://github.com/tui-rs-revival/ratatui/graphs/contributors)
-
-## Acknowledgments
-
-Special thanks to [**Pavel Fomchenkov**](https://github.com/nawok) for his work in designing **an
-awesome logo** for the ratatui project and tui-rs-revival organization.
+You might want to checkout [Cursive](https://github.com/gyscos/Cursive) for an
+alternative solution to build text user interfaces in Rust.

 ## License

-[MIT](./LICENSE)
+[MIT](LICENSE)
--- a/RELEASE.md
+++ b/RELEASE.md
@@ -1,30 +0,0 @@
-# Creating a Release
-
-[crates.io](https://crates.io/crates/ratatui) releases are automated via [GitHub
-actions](.github/workflows/cd.yml) and triggered by pushing a tag.
-
-1. Record a new demo gif. The preferred tool for this is [ttyrec](http://0xcc.net/ttyrec/) and
-   [ttygif](https://github.com/icholy/ttygif). [Asciinema](https://asciinema.org/) handles block
-   character height poorly, [termanilizer](https://www.terminalizer.com/) takes forever to render,
-   [vhs](https://github.com/charmbracelet/vhs) handles braille
-   characters poorly (though if <https://github.com/charmbracelet/vhs/issues/322> is fixed, then
-   it's probably the best option).
-
-   ```shell
-   cargo build --example demo
-   ttyrec -e 'cargo --quiet run --release --example demo -- --tick-rate 100' demo.rec
-   ttygif demo.rec
-   ```
-
-   Then upload it somewhere (e.g. use `vhs publish tty.gif` to publish it or upload it to a GitHub
-   wiki page as an attachment). Avoid adding the gif to the git repo as binary files tend to bloat
-   repositories.
-
-1. Bump the version in [Cargo.toml](Cargo.toml).
-1. Ensure [CHANGELOG.md](CHANGELOG.md) is updated. [git-cliff](https://github.com/orhun/git-cliff)
-   can be used for generating the entries.
-1. Commit and push the changes.
-1. Create a new tag: `git tag -a v[X.Y.Z]`
-1. Push the tag: `git push --tags`
-1. Wait for [Continuous Deployment](https://github.com/tui-rs-revival/ratatui/actions) workflow to
-   finish.
--- a/assets/demo.gif
+++ b/assets/demo.gif
--- a/bacon.toml
+++ b/bacon.toml
@@ -1,91 +0,0 @@
-# This is a configuration file for the bacon tool
-#
-# Bacon repository: https://github.com/Canop/bacon
-# Complete help on configuration: https://dystroy.org/bacon/config/
-# You can also check bacon's own bacon.toml file
-#  as an example: https://github.com/Canop/bacon/blob/main/bacon.toml
-
-default_job = "check"
-
-[jobs.check]
-command = ["cargo", "check", "--all-features", "--color", "always"]
-need_stdout = false
-
-[jobs.check-all]
-command = ["cargo", "check", "--all-targets", "--all-features", "--color", "always"]
-need_stdout = false
-
-[jobs.clippy]
-command = [
-    "cargo", "clippy",
-    "--all-targets",
-    "--color", "always",
-]
-need_stdout = false
-
-[jobs.test]
-command = [
-    "cargo", "test",
-    "--all-features",
-    "--color", "always",
-    "--", "--color", "always", # see https://github.com/Canop/bacon/issues/124
-]
-need_stdout = true
-
-[jobs.doc]
-command = [
-    "cargo", "+nightly", "doc",
-    "-Zunstable-options", "-Zrustdoc-scrape-examples",
-    "--all-features",
-    "--color", "always",
-    "--no-deps",
-]
-env.RUSTDOCFLAGS = "--cfg docsrs"
-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"
-need_stdout = false
-on_success = "job:doc" # so that we don't open the browser at each change
-
-# You can run your application and have the result displayed in bacon,
-# *if* it makes sense for this crate. You can run an example the same
-# way. Don't forget the `--color always` part or the errors won't be
-# properly parsed.
-[jobs.run]
-command = [
-    "cargo", "run",
-    "--color", "always",
-    # put launch parameters for your program behind a `--` separator
-]
-need_stdout = true
-allow_warnings = true
-
-[jobs.check-crossterm]
-command = ["cargo", "check", "--color", "always", "--all-targets", "--no-default-features", "--features", "crossterm"]
-
-[jobs.check-termion]
-command = ["cargo", "check", "--color", "always", "--all-targets", "--no-default-features", "--features", "termion"]
-
-[jobs.check-termwiz]
-command = ["cargo", "check", "--color", "always", "--all-targets", "--no-default-features", "--features", "termwiz"]
-
-# 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-c = "job:check-crossterm"
-ctrl-t = "job:check-termion"
-ctrl-w = "job:check-termwiz"
--- a/benches/paragraph.rs
+++ b/benches/paragraph.rs
@@ -1,89 +0,0 @@
-use criterion::{black_box, criterion_group, criterion_main, Bencher, BenchmarkId, Criterion};
-use ratatui::{
-    buffer::Buffer,
-    layout::Rect,
-    widgets::{Paragraph, Widget, Wrap},
-};
-
-/// because the scroll offset is a u16, the maximum number of lines that can be scrolled is 65535.
-/// This is a limitation of the current implementation and may be fixed by changing the type of the
-/// scroll offset to a u32.
-const MAX_SCROLL_OFFSET: u16 = u16::MAX;
-const NO_WRAP_WIDTH: u16 = 200;
-const WRAP_WIDTH: u16 = 100;
-
-/// Benchmark for rendering a paragraph with a given number of lines. The design of this benchmark
-/// allows comparison of the performance of rendering a paragraph with different numbers of lines.
-/// as well as comparing with the various settings on the scroll and wrap features.
-pub fn paragraph(c: &mut Criterion) {
-    let mut group = c.benchmark_group("paragraph");
-    for &line_count in [64, 2048, MAX_SCROLL_OFFSET].iter() {
-        let lines = random_lines(line_count);
-        let lines = lines.as_str();
-
-        // benchmark that measures the overhead of creating a paragraph separately from rendering
-        group.bench_with_input(BenchmarkId::new("new", line_count), lines, |b, lines| {
-            b.iter(|| Paragraph::new(black_box(lines)))
-        });
-
-        // render the paragraph with no scroll
-        group.bench_with_input(
-            BenchmarkId::new("render", line_count),
-            &Paragraph::new(lines),
-            |bencher, paragraph| render(bencher, paragraph, NO_WRAP_WIDTH),
-        );
-
-        // scroll the paragraph by half the number of lines and render
-        group.bench_with_input(
-            BenchmarkId::new("render_scroll_half", line_count),
-            &Paragraph::new(lines).scroll((0u16, line_count / 2)),
-            |bencher, paragraph| render(bencher, paragraph, NO_WRAP_WIDTH),
-        );
-
-        // scroll the paragraph by the full number of lines and render
-        group.bench_with_input(
-            BenchmarkId::new("render_scroll_full", line_count),
-            &Paragraph::new(lines).scroll((0u16, line_count)),
-            |bencher, paragraph| render(bencher, paragraph, NO_WRAP_WIDTH),
-        );
-
-        // render the paragraph wrapped to 100 characters
-        group.bench_with_input(
-            BenchmarkId::new("render_wrap", line_count),
-            &Paragraph::new(lines).wrap(Wrap { trim: false }),
-            |bencher, paragraph| render(bencher, paragraph, WRAP_WIDTH),
-        );
-
-        // scroll the paragraph by the full number of lines and render wrapped to 100 characters
-        group.bench_with_input(
-            BenchmarkId::new("render_wrap_scroll_full", line_count),
-            &Paragraph::new(lines)
-                .wrap(Wrap { trim: false })
-                .scroll((0u16, line_count)),
-            |bencher, paragraph| render(bencher, paragraph, WRAP_WIDTH),
-        );
-    }
-    group.finish();
-}
-
-/// render the paragraph into a buffer with the given width
-fn render(bencher: &mut Bencher, paragraph: &Paragraph, width: u16) {
-    let mut buffer = Buffer::empty(Rect::new(0, 0, width, 50));
-    bencher.iter(|| {
-        paragraph.clone().render(buffer.area, &mut buffer);
-    })
-}
-
-/// Create a string with the given number of lines filled with nonsense words
-///
-/// English language has about 5.1 average characters per word so including the space between words
-/// this should emit around 200 characters per paragraph on average.
-fn random_lines(count: u16) -> String {
-    let count = count as i64;
-    let sentence_count = 3;
-    let word_count = 11;
-    fakeit::words::paragraph(count, sentence_count, word_count, "\n".into())
-}
-
-criterion_group!(benches, paragraph);
-criterion_main!(benches);
--- a/cliff.toml
+++ b/cliff.toml
@@ -1,86 +0,0 @@
-# configuration for https://github.com/orhun/git-cliff
-
-[changelog]
-# changelog header
-header = """
-# Changelog\n
-All notable changes to this project will be documented in this file.\n
-"""
-# template for the changelog body
-# https://tera.netlify.app/docs/#introduction
-body = """
-{% if version %}\
-    ## {{ version }} - {{ timestamp | date(format="%Y-%m-%d") }}
-{% else %}\
-    ## [unreleased]
-{% endif %}\
-{% for group, commits in commits | group_by(attribute="group") %}
-    ### {{ group | striptags | trim | upper_first }}
-    {% for commit in commits
-    | filter(attribute="scope")
-    | sort(attribute="scope") %}
-        - *({{commit.scope}})* {{ commit.message | upper_first }}{% if commit.breaking %} [**breaking**]{% endif %}
-    {%- endfor -%}
-    {% raw %}\n{% endraw %}\
-    {%- for commit in commits %}
-        {%- if commit.scope -%}
-        {% else -%}
-            - *(uncategorized)* {{ commit.message | upper_first }}{% if commit.breaking %} [**breaking**]{% endif %}
-        {% endif -%}
-    {% endfor -%}
-{% endfor %}\n
-"""
-# remove the leading and trailing whitespace from the template
-trim = true
-# changelog footer
-footer = """
-<!-- generated by git-cliff -->
-"""
-
-[git]
-# parse the commits based on https://www.conventionalcommits.org
-conventional_commits = true
-# filter out the commits that are not conventional
-filter_unconventional = true
-# process each line of a commit as an individual commit
-split_commits = false
-# regex for preprocessing the commit messages
-commit_preprocessors = [
-    { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "([#${2}](https://github.com/tui-rs-revival/ratatui/issues/${2}))" },
-    { pattern = '(better safe shared layout cache)', replace = "perf(layout): ${1}" },
-    { pattern = '(Clarify README.md)', replace = "docs(readme): ${1}" },
-    { pattern = '(Update README.md)', replace = "docs(readme): ${1}" },
-    { pattern = '(fix typos|Fix typos)', replace = "fix: ${1}" },
-]
-# regex for parsing and grouping commits
-commit_parsers = [
-    { message = "^feat", group = "<!-- 00 -->Features" },
-    { message = "^[fF]ix", group = "<!-- 01 -->Bug Fixes" },
-    { message = "^refactor", group = "<!-- 02 -->Refactor" },
-    { message = "^doc", group = "<!-- 03 -->Documentation" },
-    { message = "^perf", group = "<!-- 04 -->Performance" },
-    { message = "^style", group = "<!-- 05 -->Styling" },
-    { message = "^test", group = "<!-- 06 -->Testing" },
-    { message = "^chore\\(release\\): prepare for", skip = true },
-    { message = "^chore\\(pr\\)", skip = true },
-    { message = "^chore\\(pull\\)", skip = true },
-    { message = "^chore", group = "<!-- 07 -->Miscellaneous Tasks" },
-    { body = ".*security", group = "<!-- 08 -->Security" },
-    { message = "^build", group = "<!-- 09 -->Build" },
-    { message = "^ci", group = "<!-- 10 -->Continuous Integration" },
-    { message = "^revert", group = "<!-- 11 -->Reverted Commits" },
-]
-# 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
-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"
-# regex for ignoring tags
-ignore_tags = ""
-# sort the tags topologically
-topo_order = false
-# sort the commits inside sections by oldest/newest order
-sort_commits = "newest"
--- a/committed.toml
+++ b/committed.toml
@@ -1,30 +0,0 @@
-# configuration for https://github.com/crate-ci/committed
-
-# https://www.conventionalcommits.org
-style = "conventional"
-# disallow merge commits
-merge_commit = false
-# subject is not required to be capitalized
-subject_capitalized = false
-# subject should start with an imperative verb
-imperative_subject = true
-# subject should not end with a punctuation
-subject_not_punctuated = true
-# disable line length
-line_length = 0
-# disable subject length
-subject_length = 0
-# default allowed_types [ "chore", "docs", "feat", "fix", "perf", "refactor", "style", "test" ]
-allowed_types = [
-  "build",
-  "chore",
-  "ci",
-  "docs",
-  "feat",
-  "fix",
-  "perf",
-  "refactor",
-  "revert",
-  "style",
-  "test",
-]
--- a/deny.toml
+++ b/deny.toml
@@ -1,28 +0,0 @@
-# configuration for https://github.com/EmbarkStudios/cargo-deny
-
-[licenses]
-default = "deny"
-unlicensed = "deny"
-copyleft = "deny"
-confidence-threshold = 0.8
-allow = [
-    "Apache-2.0",
-    "BSD-2-Clause",
-    "BSD-3-Clause",
-    "ISC",
-    "MIT",
-    "Unicode-DFS-2016",
-    "WTFPL",
-]
-
-[advisories]
-unmaintained = "deny"
-yanked = "deny"
-
-[bans]
-multiple-versions = "allow"
-
-[sources]
-unknown-registry = "deny"
-unknown-git = "warn"
-allow-registry = ["https://github.com/rust-lang/crates.io-index"]
--- a/examples/barchart.rs
+++ b/examples/barchart.rs
@@ -1,20 +1,15 @@
-use std::{
-    error::Error,
-    io,
-    time::{Duration, Instant},
-};
+#[allow(dead_code)]
+mod util;

-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
    layout::{Constraint, Direction, Layout},
    style::{Color, Modifier, Style},
    widgets::{BarChart, Block, Borders},
-    Frame, Terminal,
+    Terminal,
 };

 struct App<'a> {
@@ -53,110 +48,85 @@ impl<'a> App<'a> {
        }
    }

-    fn on_tick(&mut self) {
+    fn update(&mut self) {
        let value = self.data.pop().unwrap();
        self.data.insert(0, value);
    }
 }

 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);
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

-    // create app and run it
-    let tick_rate = Duration::from_millis(250);
-    let app = App::new();
-    let res = run_app(&mut terminal, app, tick_rate);
+    // Setup event handlers
+    let events = Events::new();

-    // restore terminal
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
+    // App
+    let mut app = App::new();

-    if let Err(err) = res {
-        println!("{err:?}");
+    loop {
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(2)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(f.size());
+            let barchart = BarChart::default()
+                .block(Block::default().title("Data1").borders(Borders::ALL))
+                .data(&app.data)
+                .bar_width(9)
+                .bar_style(Style::default().fg(Color::Yellow))
+                .value_style(Style::default().fg(Color::Black).bg(Color::Yellow));
+            f.render_widget(barchart, chunks[0]);
+
+            let chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(chunks[1]);
+
+            let barchart = BarChart::default()
+                .block(Block::default().title("Data2").borders(Borders::ALL))
+                .data(&app.data)
+                .bar_width(5)
+                .bar_gap(3)
+                .bar_style(Style::default().fg(Color::Green))
+                .value_style(
+                    Style::default()
+                        .bg(Color::Green)
+                        .add_modifier(Modifier::BOLD),
+                );
+            f.render_widget(barchart, chunks[0]);
+
+            let barchart = BarChart::default()
+                .block(Block::default().title("Data3").borders(Borders::ALL))
+                .data(&app.data)
+                .bar_style(Style::default().fg(Color::Red))
+                .bar_width(7)
+                .bar_gap(0)
+                .value_style(Style::default().bg(Color::Red))
+                .label_style(
+                    Style::default()
+                        .fg(Color::Cyan)
+                        .add_modifier(Modifier::ITALIC),
+                );
+            f.render_widget(barchart, chunks[1]);
+        })?;
+
+        match events.next()? {
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
+            Event::Tick => {
+                app.update();
+            }
+        }
    }

    Ok(())
 }
-
-fn run_app<B: Backend>(
-    terminal: &mut Terminal<B>,
-    mut app: App,
-    tick_rate: Duration,
-) -> io::Result<()> {
-    let mut last_tick = Instant::now();
-    loop {
-        terminal.draw(|f| ui(f, &app))?;
-
-        let timeout = tick_rate
-            .checked_sub(last_tick.elapsed())
-            .unwrap_or_else(|| Duration::from_secs(0));
-        if crossterm::event::poll(timeout)? {
-            if let Event::Key(key) = event::read()? {
-                if let KeyCode::Char('q') = key.code {
-                    return Ok(());
-                }
-            }
-        }
-        if last_tick.elapsed() >= tick_rate {
-            app.on_tick();
-            last_tick = Instant::now();
-        }
-    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .margin(2)
-        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-        .split(f.size());
-    let barchart = BarChart::default()
-        .block(Block::default().title("Data1").borders(Borders::ALL))
-        .data(&app.data)
-        .bar_width(9)
-        .bar_style(Style::default().fg(Color::Yellow))
-        .value_style(Style::default().fg(Color::Black).bg(Color::Yellow));
-    f.render_widget(barchart, chunks[0]);
-
-    let chunks = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-        .split(chunks[1]);
-
-    let barchart = BarChart::default()
-        .block(Block::default().title("Data2").borders(Borders::ALL))
-        .data(&app.data)
-        .bar_width(5)
-        .bar_gap(3)
-        .bar_style(Style::default().fg(Color::Green))
-        .value_style(
-            Style::default()
-                .bg(Color::Green)
-                .add_modifier(Modifier::BOLD),
-        );
-    f.render_widget(barchart, chunks[0]);
-
-    let barchart = BarChart::default()
-        .block(Block::default().title("Data3").borders(Borders::ALL))
-        .data(&app.data)
-        .bar_style(Style::default().fg(Color::Red))
-        .bar_width(7)
-        .bar_gap(0)
-        .value_style(Style::default().bg(Color::Red))
-        .label_style(
-            Style::default()
-                .fg(Color::Cyan)
-                .add_modifier(Modifier::ITALIC),
-        );
-    f.render_widget(barchart, chunks[1]);
-}
--- a/examples/block.rs
+++ b/examples/block.rs
@@ -1,126 +1,101 @@
-use std::{error::Error, io};
+#[allow(dead_code)]
+mod util;

-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
    layout::{Alignment, Constraint, Direction, Layout},
-    style::{Color, Style, Stylize},
-    widgets::{block::title::Title, Block, BorderType, Borders, Padding, Paragraph},
-    Frame, Terminal,
+    style::{Color, Modifier, Style},
+    text::Span,
+    widgets::{Block, BorderType, Borders},
+    Terminal,
 };

 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);
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

-    // create app and run it
-    let res = run_app(&mut terminal);
+    // Setup event handlers
+    let events = Events::new();

-    // 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<()> {
    loop {
-        terminal.draw(ui)?;
+        terminal.draw(|f| {
+            // Wrapping block for a group
+            // Just draw the block and the group on the same area and build the group
+            // with at least a margin of 1
+            let size = f.size();

-        if let Event::Key(key) = event::read()? {
-            if let KeyCode::Char('q') = key.code {
-                return Ok(());
+            // Surrounding block
+            let block = Block::default()
+                .borders(Borders::ALL)
+                .title("Main block with round corners")
+                .title_alignment(Alignment::Center)
+                .border_type(BorderType::Rounded);
+            f.render_widget(block, size);
+
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(4)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(f.size());
+
+            // Top two inner blocks
+            let top_chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(chunks[0]);
+
+            // Top left inner block with green background
+            let block = Block::default()
+                .title(vec![
+                    Span::styled("With", Style::default().fg(Color::Yellow)),
+                    Span::from(" background"),
+                ])
+                .style(Style::default().bg(Color::Green));
+            f.render_widget(block, top_chunks[0]);
+
+            // Top right inner block with styled title aligned to the right
+            let block = Block::default()
+                .title(Span::styled(
+                    "Styled title",
+                    Style::default()
+                        .fg(Color::White)
+                        .bg(Color::Red)
+                        .add_modifier(Modifier::BOLD),
+                ))
+                .title_alignment(Alignment::Right);
+            f.render_widget(block, top_chunks[1]);
+
+            // Bottom two inner blocks
+            let bottom_chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(chunks[1]);
+
+            // Bottom left block with all default borders
+            let block = Block::default().title("With borders").borders(Borders::ALL);
+            f.render_widget(block, bottom_chunks[0]);
+
+            // Bottom right block with styled left and right border
+            let block = Block::default()
+                .title("With styled borders and doubled borders")
+                .border_style(Style::default().fg(Color::Cyan))
+                .borders(Borders::LEFT | Borders::RIGHT)
+                .border_type(BorderType::Double);
+            f.render_widget(block, bottom_chunks[1]);
+        })?;
+
+        if let Event::Input(key) = events.next()? {
+            if key == Key::Char('q') {
+                break;
            }
        }
    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>) {
-    // Wrapping block for a group
-    // Just draw the block and the group on the same area and build the group
-    // with at least a margin of 1
-    let size = f.size();
-
-    // Surrounding block
-    let block = Block::default()
-        .borders(Borders::ALL)
-        .title(Title::from("Main block with round corners").alignment(Alignment::Center))
-        .border_type(BorderType::Rounded);
-    f.render_widget(block, size);
-
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .margin(4)
-        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-        .split(f.size());
-
-    // Top two inner blocks
-    let top_chunks = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-        .split(chunks[0]);
-
-    // Top left inner block with green background
-    let block = Block::default()
-        .title(vec!["With".yellow(), " background".into()])
-        .on_green();
-    f.render_widget(block, top_chunks[0]);
-
-    // Top right inner block with styled title aligned to the right
-    let block = Block::default()
-        .title(Title::from("Styled title".white().on_red().bold()).alignment(Alignment::Right));
-    f.render_widget(block, top_chunks[1]);
-
-    // Bottom two inner blocks
-    let bottom_chunks = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-        .split(chunks[1]);
-
-    // Bottom left block with all default borders
-    let block = Block::default()
-        .title("With borders")
-        .borders(Borders::ALL)
-        .padding(Padding {
-            left: 4,
-            right: 4,
-            top: 2,
-            bottom: 2,
-        });
-
-    let text = Paragraph::new("text inside padded block").block(block);
-    f.render_widget(text, bottom_chunks[0]);
-
-    // Bottom right block with styled left and right border
-    let block = Block::default()
-        .title("With styled borders and doubled borders")
-        .border_style(Style::default().fg(Color::Cyan))
-        .borders(Borders::LEFT | Borders::RIGHT)
-        .border_type(BorderType::Double)
-        .padding(Padding::uniform(1));
-
-    let inner_block = Block::default()
-        .title("Block inside padded block")
-        .borders(Borders::ALL);
-
-    let inner_area = block.inner(bottom_chunks[1]);
-    f.render_widget(block, bottom_chunks[1]);
-    f.render_widget(inner_block, inner_area);
+    Ok(())
 }
--- a/examples/calendar.rs
+++ b/examples/calendar.rs
@@ -1,283 +0,0 @@
-use std::{error::Error, io, rc::Rc};
-
-use crossterm::{
-    event::{self, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
-    layout::{Constraint, Direction, Layout, Rect},
-    style::{Color, Modifier, Style},
-    widgets::calendar::{CalendarEventStore, DateStyler, Monthly},
-    Frame, Terminal,
-};
-use time::{Date, Month, OffsetDateTime};
-
-fn main() -> Result<(), Box<dyn Error>> {
-    enable_raw_mode()?;
-    let mut stdout = io::stdout();
-    execute!(stdout, EnterAlternateScreen)?;
-    let backend = CrosstermBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
-
-    loop {
-        let _ = terminal.draw(|f| draw(f));
-
-        if let Event::Key(key) = event::read()? {
-            #[allow(clippy::single_match)]
-            match key.code {
-                KeyCode::Char(_) => {
-                    break;
-                }
-                _ => {}
-            };
-        }
-    }
-
-    disable_raw_mode()?;
-    execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-    terminal.show_cursor()?;
-    Ok(())
-}
-
-fn draw<B: Backend>(f: &mut Frame<B>) {
-    let app_area = f.size();
-
-    let calarea = Rect {
-        x: app_area.x + 1,
-        y: app_area.y + 1,
-        height: app_area.height - 1,
-        width: app_area.width - 1,
-    };
-
-    let mut start = OffsetDateTime::now_local()
-        .unwrap()
-        .date()
-        .replace_month(Month::January)
-        .unwrap()
-        .replace_day(1)
-        .unwrap();
-
-    let list = make_dates(start.year());
-
-    for chunk in split_rows(&calarea)
-        .iter()
-        .flat_map(|row| split_cols(row).to_vec())
-    {
-        let cal = cals::get_cal(start.month(), start.year(), &list);
-        f.render_widget(cal, chunk);
-        start = start.replace_month(start.month().next()).unwrap();
-    }
-}
-
-fn split_rows(area: &Rect) -> Rc<[Rect]> {
-    let list_layout = Layout::default()
-        .direction(Direction::Vertical)
-        .margin(0)
-        .constraints(
-            [
-                Constraint::Percentage(33),
-                Constraint::Percentage(33),
-                Constraint::Percentage(33),
-            ]
-            .as_ref(),
-        );
-
-    list_layout.split(*area)
-}
-
-fn split_cols(area: &Rect) -> Rc<[Rect]> {
-    let list_layout = Layout::default()
-        .direction(Direction::Horizontal)
-        .margin(0)
-        .constraints(
-            [
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-            ]
-            .as_ref(),
-        );
-
-    list_layout.split(*area)
-}
-
-fn make_dates(current_year: i32) -> CalendarEventStore {
-    let mut list = CalendarEventStore::today(
-        Style::default()
-            .add_modifier(Modifier::BOLD)
-            .bg(Color::Blue),
-    );
-
-    // Holidays
-    let holiday_style = Style::default()
-        .fg(Color::Red)
-        .add_modifier(Modifier::UNDERLINED);
-
-    // new year's
-    list.add(
-        Date::from_calendar_date(current_year, Month::January, 1).unwrap(),
-        holiday_style,
-    );
-    // next new_year's for December "show surrounding"
-    list.add(
-        Date::from_calendar_date(current_year + 1, Month::January, 1).unwrap(),
-        holiday_style,
-    );
-    // groundhog day
-    list.add(
-        Date::from_calendar_date(current_year, Month::February, 2).unwrap(),
-        holiday_style,
-    );
-    // april fool's
-    list.add(
-        Date::from_calendar_date(current_year, Month::April, 1).unwrap(),
-        holiday_style,
-    );
-    // earth day
-    list.add(
-        Date::from_calendar_date(current_year, Month::April, 22).unwrap(),
-        holiday_style,
-    );
-    // star wars day
-    list.add(
-        Date::from_calendar_date(current_year, Month::May, 4).unwrap(),
-        holiday_style,
-    );
-    // festivus
-    list.add(
-        Date::from_calendar_date(current_year, Month::December, 23).unwrap(),
-        holiday_style,
-    );
-    // new year's eve
-    list.add(
-        Date::from_calendar_date(current_year, Month::December, 31).unwrap(),
-        holiday_style,
-    );
-
-    // seasons
-    let season_style = Style::default()
-        .fg(Color::White)
-        .bg(Color::Yellow)
-        .add_modifier(Modifier::UNDERLINED);
-    // spring equinox
-    list.add(
-        Date::from_calendar_date(current_year, Month::March, 22).unwrap(),
-        season_style,
-    );
-    // summer solstice
-    list.add(
-        Date::from_calendar_date(current_year, Month::June, 21).unwrap(),
-        season_style,
-    );
-    // fall equinox
-    list.add(
-        Date::from_calendar_date(current_year, Month::September, 22).unwrap(),
-        season_style,
-    );
-    list.add(
-        Date::from_calendar_date(current_year, Month::December, 21).unwrap(),
-        season_style,
-    );
-    list
-}
-
-mod cals {
-    use super::*;
-
-    pub(super) fn get_cal<'a, S: DateStyler>(m: Month, y: i32, es: S) -> Monthly<'a, S> {
-        use Month::*;
-        match m {
-            May => example1(m, y, es),
-            June => example2(m, y, es),
-            July => example3(m, y, es),
-            December => example3(m, y, es),
-            February => example4(m, y, es),
-            November => example5(m, y, es),
-            _ => default(m, y, es),
-        }
-    }
-
-    fn default<'a, S: DateStyler>(m: Month, y: i32, es: S) -> Monthly<'a, S> {
-        let default_style = Style::default()
-            .add_modifier(Modifier::BOLD)
-            .bg(Color::Rgb(50, 50, 50));
-
-        Monthly::new(Date::from_calendar_date(y, m, 1).unwrap(), es)
-            .show_month_header(Style::default())
-            .default_style(default_style)
-    }
-
-    fn example1<'a, S: DateStyler>(m: Month, y: i32, es: S) -> Monthly<'a, S> {
-        let default_style = Style::default()
-            .add_modifier(Modifier::BOLD)
-            .bg(Color::Rgb(50, 50, 50));
-
-        Monthly::new(Date::from_calendar_date(y, m, 1).unwrap(), es)
-            .show_surrounding(default_style)
-            .default_style(default_style)
-            .show_month_header(Style::default())
-    }
-
-    fn example2<'a, S: DateStyler>(m: Month, y: i32, es: S) -> Monthly<'a, S> {
-        let header_style = Style::default()
-            .add_modifier(Modifier::BOLD)
-            .add_modifier(Modifier::DIM)
-            .fg(Color::LightYellow);
-
-        let default_style = Style::default()
-            .add_modifier(Modifier::BOLD)
-            .bg(Color::Rgb(50, 50, 50));
-
-        Monthly::new(Date::from_calendar_date(y, m, 1).unwrap(), es)
-            .show_weekdays_header(header_style)
-            .default_style(default_style)
-            .show_month_header(Style::default())
-    }
-
-    fn example3<'a, S: DateStyler>(m: Month, y: i32, es: S) -> Monthly<'a, S> {
-        let header_style = Style::default()
-            .add_modifier(Modifier::BOLD)
-            .fg(Color::Green);
-
-        let default_style = Style::default()
-            .add_modifier(Modifier::BOLD)
-            .bg(Color::Rgb(50, 50, 50));
-
-        Monthly::new(Date::from_calendar_date(y, m, 1).unwrap(), es)
-            .show_surrounding(Style::default().add_modifier(Modifier::DIM))
-            .show_weekdays_header(header_style)
-            .default_style(default_style)
-            .show_month_header(Style::default())
-    }
-
-    fn example4<'a, S: DateStyler>(m: Month, y: i32, es: S) -> Monthly<'a, S> {
-        let header_style = Style::default()
-            .add_modifier(Modifier::BOLD)
-            .fg(Color::Green);
-
-        let default_style = Style::default()
-            .add_modifier(Modifier::BOLD)
-            .bg(Color::Rgb(50, 50, 50));
-
-        Monthly::new(Date::from_calendar_date(y, m, 1).unwrap(), es)
-            .show_weekdays_header(header_style)
-            .default_style(default_style)
-    }
-
-    fn example5<'a, S: DateStyler>(m: Month, y: i32, es: S) -> Monthly<'a, S> {
-        let header_style = Style::default()
-            .add_modifier(Modifier::BOLD)
-            .fg(Color::Green);
-
-        let default_style = Style::default()
-            .add_modifier(Modifier::BOLD)
-            .bg(Color::Rgb(50, 50, 50));
-
-        Monthly::new(Date::from_calendar_date(y, m, 1).unwrap(), es)
-            .show_month_header(header_style)
-            .default_style(default_style)
-    }
-}
--- a/examples/canvas.rs
+++ b/examples/canvas.rs
@@ -1,24 +1,18 @@
-use std::{
-    error::Error,
-    io,
-    time::{Duration, Instant},
-};
+#[allow(dead_code)]
+mod util;

-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
+use crate::util::event::{Config, Event, Events};
+use std::{error::Error, io, time::Duration};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
    layout::{Constraint, Direction, Layout, Rect},
-    style::{Color, Stylize},
-    symbols::Marker,
+    style::Color,
    widgets::{
        canvas::{Canvas, Map, MapResolution, Rectangle},
        Block, Borders,
    },
-    Frame, Terminal,
+    Terminal,
 };

 struct App {
@@ -30,8 +24,6 @@ struct App {
    vy: f64,
    dir_x: bool,
    dir_y: bool,
-    tick_count: u64,
-    marker: Marker,
 }

 impl App {
@@ -51,22 +43,10 @@ impl App {
            vy: 1.0,
            dir_x: true,
            dir_y: true,
-            tick_count: 0,
-            marker: Marker::Dot,
        }
    }

-    fn on_tick(&mut self) {
-        self.tick_count += 1;
-        // only change marker every 4 ticks (1s) to avoid stroboscopic effect
-        if (self.tick_count % 4) == 0 {
-            self.marker = match self.marker {
-                Marker::Dot => Marker::Block,
-                Marker::Block => Marker::Bar,
-                Marker::Bar => Marker::Braille,
-                Marker::Braille => Marker::Dot,
-            };
-        }
+    fn update(&mut self) {
        if self.ball.x < self.playground.left() as f64
            || self.ball.x + self.ball.width > self.playground.right() as f64
        {
@@ -93,101 +73,76 @@ impl App {
 }

 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);
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

-    // create app and run it
-    let tick_rate = Duration::from_millis(250);
-    let app = App::new();
-    let res = run_app(&mut terminal, app, tick_rate);
+    // Setup event handlers
+    let config = Config {
+        tick_rate: Duration::from_millis(250),
+        ..Default::default()
+    };
+    let events = Events::with_config(config);

-    // restore terminal
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
+    // App
+    let mut app = App::new();

-    if let Err(err) = res {
-        println!("{err:?}");
+    loop {
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(f.size());
+            let canvas = Canvas::default()
+                .block(Block::default().borders(Borders::ALL).title("World"))
+                .paint(|ctx| {
+                    ctx.draw(&Map {
+                        color: Color::White,
+                        resolution: MapResolution::High,
+                    });
+                    ctx.print(app.x, -app.y, "You are here", Color::Yellow);
+                })
+                .x_bounds([-180.0, 180.0])
+                .y_bounds([-90.0, 90.0]);
+            f.render_widget(canvas, chunks[0]);
+            let canvas = Canvas::default()
+                .block(Block::default().borders(Borders::ALL).title("Pong"))
+                .paint(|ctx| {
+                    ctx.draw(&app.ball);
+                })
+                .x_bounds([10.0, 110.0])
+                .y_bounds([10.0, 110.0]);
+            f.render_widget(canvas, chunks[1]);
+        })?;
+
+        match events.next()? {
+            Event::Input(input) => match input {
+                Key::Char('q') => {
+                    break;
+                }
+                Key::Down => {
+                    app.y += 1.0;
+                }
+                Key::Up => {
+                    app.y -= 1.0;
+                }
+                Key::Right => {
+                    app.x += 1.0;
+                }
+                Key::Left => {
+                    app.x -= 1.0;
+                }
+
+                _ => {}
+            },
+            Event::Tick => {
+                app.update();
+            }
+        }
    }

    Ok(())
 }
-
-fn run_app<B: Backend>(
-    terminal: &mut Terminal<B>,
-    mut app: App,
-    tick_rate: Duration,
-) -> io::Result<()> {
-    let mut last_tick = Instant::now();
-    loop {
-        terminal.draw(|f| ui(f, &app))?;
-
-        let timeout = tick_rate
-            .checked_sub(last_tick.elapsed())
-            .unwrap_or_else(|| Duration::from_secs(0));
-        if event::poll(timeout)? {
-            if let Event::Key(key) = event::read()? {
-                match key.code {
-                    KeyCode::Char('q') => {
-                        return Ok(());
-                    }
-                    KeyCode::Down => {
-                        app.y += 1.0;
-                    }
-                    KeyCode::Up => {
-                        app.y -= 1.0;
-                    }
-                    KeyCode::Right => {
-                        app.x += 1.0;
-                    }
-                    KeyCode::Left => {
-                        app.x -= 1.0;
-                    }
-                    _ => {}
-                }
-            }
-        }
-
-        if last_tick.elapsed() >= tick_rate {
-            app.on_tick();
-            last_tick = Instant::now();
-        }
-    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
-    let chunks = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-        .split(f.size());
-    let canvas = Canvas::default()
-        .block(Block::default().borders(Borders::ALL).title("World"))
-        .marker(app.marker)
-        .paint(|ctx| {
-            ctx.draw(&Map {
-                color: Color::White,
-                resolution: MapResolution::High,
-            });
-            ctx.print(app.x, -app.y, "You are here".yellow());
-        })
-        .x_bounds([-180.0, 180.0])
-        .y_bounds([-90.0, 90.0]);
-    f.render_widget(canvas, chunks[0]);
-    let canvas = Canvas::default()
-        .block(Block::default().borders(Borders::ALL).title("Pong"))
-        .marker(app.marker)
-        .paint(|ctx| {
-            ctx.draw(&app.ball);
-        })
-        .x_bounds([10.0, 110.0])
-        .y_bounds([10.0, 110.0]);
-    f.render_widget(canvas, chunks[1]);
-}
--- a/examples/chart.rs
+++ b/examples/chart.rs
@@ -1,22 +1,20 @@
-use std::{
-    error::Error,
-    io,
-    time::{Duration, Instant},
-};
+#[allow(dead_code)]
+mod util;

-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+use crate::util::{
+    event::{Event, Events},
+    SinSignal,
 };
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
    layout::{Constraint, Direction, Layout},
-    style::{Color, Modifier, Style, Stylize},
+    style::{Color, Modifier, Style},
    symbols,
    text::Span,
    widgets::{Axis, Block, Borders, Chart, Dataset, GraphType},
-    Frame, Terminal,
+    Terminal,
 };

 const DATA: [(f64, f64); 5] = [(0.0, 0.0), (1.0, 1.0), (2.0, 2.0), (3.0, 3.0), (4.0, 4.0)];
@@ -30,34 +28,6 @@ const DATA2: [(f64, f64); 7] = [
    (60.0, 3.0),
 ];

-#[derive(Clone)]
-pub struct SinSignal {
-    x: f64,
-    interval: f64,
-    period: f64,
-    scale: f64,
-}
-
-impl SinSignal {
-    pub fn new(interval: f64, period: f64, scale: f64) -> SinSignal {
-        SinSignal {
-            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)
-    }
-}
-
 struct App {
    signal1: SinSignal,
    data1: Vec<(f64, f64)>,
@@ -81,7 +51,7 @@ impl App {
        }
    }

-    fn on_tick(&mut self) {
+    fn update(&mut self) {
        for _ in 0..5 {
            self.data1.remove(0);
        }
@@ -96,172 +66,181 @@ impl App {
 }

 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);
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

-    // create app and run it
-    let tick_rate = Duration::from_millis(250);
-    let app = App::new();
-    let res = run_app(&mut terminal, app, tick_rate);
+    let events = Events::new();

-    // restore terminal
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
+    // App
+    let mut app = App::new();

-    if let Err(err) = res {
-        println!("{err:?}");
+    loop {
+        terminal.draw(|f| {
+            let size = f.size();
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .constraints(
+                    [
+                        Constraint::Ratio(1, 3),
+                        Constraint::Ratio(1, 3),
+                        Constraint::Ratio(1, 3),
+                    ]
+                    .as_ref(),
+                )
+                .split(size);
+            let x_labels = vec![
+                Span::styled(
+                    format!("{}", app.window[0]),
+                    Style::default().add_modifier(Modifier::BOLD),
+                ),
+                Span::raw(format!("{}", (app.window[0] + app.window[1]) / 2.0)),
+                Span::styled(
+                    format!("{}", app.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(&app.data1),
+                Dataset::default()
+                    .name("data3")
+                    .marker(symbols::Marker::Braille)
+                    .style(Style::default().fg(Color::Yellow))
+                    .data(&app.data2),
+            ];
+
+            let chart = Chart::new(datasets)
+                .block(
+                    Block::default()
+                        .title(Span::styled(
+                            "Chart 1",
+                            Style::default()
+                                .fg(Color::Cyan)
+                                .add_modifier(Modifier::BOLD),
+                        ))
+                        .borders(Borders::ALL),
+                )
+                .x_axis(
+                    Axis::default()
+                        .title("X Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .labels(x_labels)
+                        .bounds(app.window),
+                )
+                .y_axis(
+                    Axis::default()
+                        .title("Y Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .labels(vec![
+                            Span::styled("-20", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("0"),
+                            Span::styled("20", Style::default().add_modifier(Modifier::BOLD)),
+                        ])
+                        .bounds([-20.0, 20.0]),
+                );
+            f.render_widget(chart, chunks[0]);
+
+            let datasets = vec![Dataset::default()
+                .name("data")
+                .marker(symbols::Marker::Braille)
+                .style(Style::default().fg(Color::Yellow))
+                .graph_type(GraphType::Line)
+                .data(&DATA)];
+            let chart = Chart::new(datasets)
+                .block(
+                    Block::default()
+                        .title(Span::styled(
+                            "Chart 2",
+                            Style::default()
+                                .fg(Color::Cyan)
+                                .add_modifier(Modifier::BOLD),
+                        ))
+                        .borders(Borders::ALL),
+                )
+                .x_axis(
+                    Axis::default()
+                        .title("X Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .bounds([0.0, 5.0])
+                        .labels(vec![
+                            Span::styled("0", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("2.5"),
+                            Span::styled("5.0", Style::default().add_modifier(Modifier::BOLD)),
+                        ]),
+                )
+                .y_axis(
+                    Axis::default()
+                        .title("Y Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .bounds([0.0, 5.0])
+                        .labels(vec![
+                            Span::styled("0", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("2.5"),
+                            Span::styled("5.0", Style::default().add_modifier(Modifier::BOLD)),
+                        ]),
+                );
+            f.render_widget(chart, chunks[1]);
+
+            let datasets = vec![Dataset::default()
+                .name("data")
+                .marker(symbols::Marker::Braille)
+                .style(Style::default().fg(Color::Yellow))
+                .graph_type(GraphType::Line)
+                .data(&DATA2)];
+            let chart = Chart::new(datasets)
+                .block(
+                    Block::default()
+                        .title(Span::styled(
+                            "Chart 3",
+                            Style::default()
+                                .fg(Color::Cyan)
+                                .add_modifier(Modifier::BOLD),
+                        ))
+                        .borders(Borders::ALL),
+                )
+                .x_axis(
+                    Axis::default()
+                        .title("X Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .bounds([0.0, 50.0])
+                        .labels(vec![
+                            Span::styled("0", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("25"),
+                            Span::styled("50", Style::default().add_modifier(Modifier::BOLD)),
+                        ]),
+                )
+                .y_axis(
+                    Axis::default()
+                        .title("Y Axis")
+                        .style(Style::default().fg(Color::Gray))
+                        .bounds([0.0, 5.0])
+                        .labels(vec![
+                            Span::styled("0", Style::default().add_modifier(Modifier::BOLD)),
+                            Span::raw("2.5"),
+                            Span::styled("5", Style::default().add_modifier(Modifier::BOLD)),
+                        ]),
+                );
+            f.render_widget(chart, chunks[2]);
+        })?;
+
+        match events.next()? {
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
+            Event::Tick => {
+                app.update();
+            }
+        }
    }

    Ok(())
 }
-
-fn run_app<B: Backend>(
-    terminal: &mut Terminal<B>,
-    mut app: App,
-    tick_rate: Duration,
-) -> io::Result<()> {
-    let mut last_tick = Instant::now();
-    loop {
-        terminal.draw(|f| ui(f, &app))?;
-
-        let timeout = tick_rate
-            .checked_sub(last_tick.elapsed())
-            .unwrap_or_else(|| Duration::from_secs(0));
-        if crossterm::event::poll(timeout)? {
-            if let Event::Key(key) = event::read()? {
-                if let KeyCode::Char('q') = key.code {
-                    return Ok(());
-                }
-            }
-        }
-        if last_tick.elapsed() >= tick_rate {
-            app.on_tick();
-            last_tick = Instant::now();
-        }
-    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
-    let size = f.size();
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints(
-            [
-                Constraint::Ratio(1, 3),
-                Constraint::Ratio(1, 3),
-                Constraint::Ratio(1, 3),
-            ]
-            .as_ref(),
-        )
-        .split(size);
-    let x_labels = vec![
-        Span::styled(
-            format!("{}", app.window[0]),
-            Style::default().add_modifier(Modifier::BOLD),
-        ),
-        Span::raw(format!("{}", (app.window[0] + app.window[1]) / 2.0)),
-        Span::styled(
-            format!("{}", app.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(&app.data1),
-        Dataset::default()
-            .name("data3")
-            .marker(symbols::Marker::Braille)
-            .style(Style::default().fg(Color::Yellow))
-            .data(&app.data2),
-    ];
-
-    let chart = Chart::new(datasets)
-        .block(
-            Block::default()
-                .title("Chart 1".cyan().bold())
-                .borders(Borders::ALL),
-        )
-        .x_axis(
-            Axis::default()
-                .title("X Axis")
-                .style(Style::default().fg(Color::Gray))
-                .labels(x_labels)
-                .bounds(app.window),
-        )
-        .y_axis(
-            Axis::default()
-                .title("Y Axis")
-                .style(Style::default().fg(Color::Gray))
-                .labels(vec!["-20".bold(), "0".into(), "20".bold()])
-                .bounds([-20.0, 20.0]),
-        );
-    f.render_widget(chart, chunks[0]);
-
-    let datasets = vec![Dataset::default()
-        .name("data")
-        .marker(symbols::Marker::Braille)
-        .style(Style::default().fg(Color::Yellow))
-        .graph_type(GraphType::Line)
-        .data(&DATA)];
-    let chart = Chart::new(datasets)
-        .block(
-            Block::default()
-                .title("Chart 2".cyan().bold())
-                .borders(Borders::ALL),
-        )
-        .x_axis(
-            Axis::default()
-                .title("X Axis")
-                .style(Style::default().fg(Color::Gray))
-                .bounds([0.0, 5.0])
-                .labels(vec!["0".bold(), "2.5".into(), "5.0".bold()]),
-        )
-        .y_axis(
-            Axis::default()
-                .title("Y Axis")
-                .style(Style::default().fg(Color::Gray))
-                .bounds([0.0, 5.0])
-                .labels(vec!["0".bold(), "2.5".into(), "5.0".bold()]),
-        );
-    f.render_widget(chart, chunks[1]);
-
-    let datasets = vec![Dataset::default()
-        .name("data")
-        .marker(symbols::Marker::Braille)
-        .style(Style::default().fg(Color::Yellow))
-        .graph_type(GraphType::Line)
-        .data(&DATA2)];
-    let chart = Chart::new(datasets)
-        .block(
-            Block::default()
-                .title("Chart 3".cyan().bold())
-                .borders(Borders::ALL),
-        )
-        .x_axis(
-            Axis::default()
-                .title("X Axis")
-                .style(Style::default().fg(Color::Gray))
-                .bounds([0.0, 50.0])
-                .labels(vec!["0".bold(), "25".into(), "50".bold()]),
-        )
-        .y_axis(
-            Axis::default()
-                .title("Y Axis")
-                .style(Style::default().fg(Color::Gray))
-                .bounds([0.0, 5.0])
-                .labels(vec!["0".bold(), "2.5".into(), "5".bold()]),
-        );
-    f.render_widget(chart, chunks[2]);
-}
--- a/examples/crossterm_demo.rs
+++ b/examples/crossterm_demo.rs
@@ -0,0 +1,108 @@
+#[allow(dead_code)]
+mod demo;
+#[allow(dead_code)]
+mod util;
+
+use crate::demo::{ui, App};
+use argh::FromArgs;
+use crossterm::{
+    event::{self, DisableMouseCapture, EnableMouseCapture, Event as CEvent, KeyCode},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+};
+use std::{
+    error::Error,
+    io::stdout,
+    sync::mpsc,
+    thread,
+    time::{Duration, Instant},
+};
+use tui::{backend::CrosstermBackend, Terminal};
+
+enum Event<I> {
+    Input(I),
+    Tick,
+}
+
+/// Crossterm demo
+#[derive(Debug, FromArgs)]
+struct Cli {
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
+    tick_rate: u64,
+    /// whether unicode symbols are used to improve the overall look of the app
+    #[argh(option, default = "true")]
+    enhanced_graphics: bool,
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
+
+    enable_raw_mode()?;
+
+    let mut stdout = stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+
+    let backend = CrosstermBackend::new(stdout);
+
+    let mut terminal = Terminal::new(backend)?;
+
+    // Setup input handling
+    let (tx, rx) = mpsc::channel();
+
+    let tick_rate = Duration::from_millis(cli.tick_rate);
+    thread::spawn(move || {
+        let mut last_tick = Instant::now();
+        loop {
+            // poll for tick rate duration, if no events, sent tick event.
+            let timeout = tick_rate
+                .checked_sub(last_tick.elapsed())
+                .unwrap_or_else(|| Duration::from_secs(0));
+            if event::poll(timeout).unwrap() {
+                if let CEvent::Key(key) = event::read().unwrap() {
+                    tx.send(Event::Input(key)).unwrap();
+                }
+            }
+            if last_tick.elapsed() >= tick_rate {
+                tx.send(Event::Tick).unwrap();
+                last_tick = Instant::now();
+            }
+        }
+    });
+
+    let mut app = App::new("Crossterm Demo", cli.enhanced_graphics);
+
+    terminal.clear()?;
+
+    loop {
+        terminal.draw(|f| ui::draw(f, &mut app))?;
+        match rx.recv()? {
+            Event::Input(event) => match event.code {
+                KeyCode::Char('q') => {
+                    disable_raw_mode()?;
+                    execute!(
+                        terminal.backend_mut(),
+                        LeaveAlternateScreen,
+                        DisableMouseCapture
+                    )?;
+                    terminal.show_cursor()?;
+                    break;
+                }
+                KeyCode::Char(c) => app.on_key(c),
+                KeyCode::Left => app.on_left(),
+                KeyCode::Up => app.on_up(),
+                KeyCode::Right => app.on_right(),
+                KeyCode::Down => app.on_down(),
+                _ => {}
+            },
+            Event::Tick => {
+                app.on_tick();
+            }
+        }
+        if app.should_quit {
+            break;
+        }
+    }
+
+    Ok(())
+}
--- a/examples/curses_demo.rs
+++ b/examples/curses_demo.rs
@@ -0,0 +1,74 @@
+mod demo;
+#[allow(dead_code)]
+mod util;
+
+use crate::demo::{ui, App};
+use argh::FromArgs;
+use std::{
+    error::Error,
+    io,
+    time::{Duration, Instant},
+};
+use tui::{backend::CursesBackend, Terminal};
+
+/// Curses demo
+#[derive(Debug, FromArgs)]
+struct Cli {
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
+    tick_rate: u64,
+    /// whether unicode symbols are used to improve the overall look of the app
+    #[argh(option, default = "true")]
+    enhanced_graphics: bool,
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
+
+    let mut backend =
+        CursesBackend::new().ok_or_else(|| io::Error::new(io::ErrorKind::Other, ""))?;
+    let curses = backend.get_curses_mut();
+    curses.set_echo(false);
+    curses.set_input_timeout(easycurses::TimeoutMode::WaitUpTo(50));
+    curses.set_input_mode(easycurses::InputMode::RawCharacter);
+    curses.set_keypad_enabled(true);
+    let mut terminal = Terminal::new(backend)?;
+    terminal.hide_cursor()?;
+
+    let mut app = App::new("Curses demo", cli.enhanced_graphics);
+
+    let mut last_tick = Instant::now();
+    let tick_rate = Duration::from_millis(cli.tick_rate);
+    loop {
+        terminal.draw(|f| ui::draw(f, &mut app))?;
+        if let Some(input) = terminal.backend_mut().get_curses_mut().get_input() {
+            match input {
+                easycurses::Input::Character(c) => {
+                    app.on_key(c);
+                }
+                easycurses::Input::KeyUp => {
+                    app.on_up();
+                }
+                easycurses::Input::KeyDown => {
+                    app.on_down();
+                }
+                easycurses::Input::KeyLeft => {
+                    app.on_left();
+                }
+                easycurses::Input::KeyRight => {
+                    app.on_right();
+                }
+                _ => {}
+            };
+        };
+        terminal.backend_mut().get_curses_mut().flush_input();
+        if last_tick.elapsed() > tick_rate {
+            app.on_tick();
+            last_tick = Instant::now();
+        }
+        if app.should_quit {
+            break;
+        }
+    }
+    Ok(())
+}
--- a/examples/custom_widget.rs
+++ b/examples/custom_widget.rs
@@ -1,24 +1,23 @@
+#[allow(dead_code)]
+mod util;
+
+use crate::util::event::{Event, Events};
 use std::{error::Error, io};
-
-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
-    buffer::Buffer,
-    layout::Rect,
-    style::Style,
-    widgets::Widget,
-    Frame, Terminal,
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend, buffer::Buffer, layout::Rect, style::Style, widgets::Widget, Terminal,
 };

-#[derive(Default)]
 struct Label<'a> {
    text: &'a str,
 }

+impl<'a> Default for Label<'a> {
+    fn default() -> Label<'a> {
+        Label { text: "" }
+    }
+}
+
 impl<'a> Widget for Label<'a> {
    fn render(self, area: Rect, buf: &mut Buffer) {
        buf.set_string(area.left(), area.top(), self.text, Style::default());
@@ -33,46 +32,28 @@ impl<'a> Label<'a> {
 }

 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);
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

-    // create app and run it
-    let res = run_app(&mut terminal);
+    let events = Events::new();

-    // restore terminal
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
+    loop {
+        terminal.draw(|f| {
+            let size = f.size();
+            let label = Label::default().text("Test");
+            f.render_widget(label, size);
+        })?;

-    if let Err(err) = res {
-        println!("{err:?}");
+        if let Event::Input(key) = events.next()? {
+            if key == Key::Char('q') {
+                break;
+            }
+        }
    }

    Ok(())
 }
-
-fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> io::Result<()> {
-    loop {
-        terminal.draw(ui)?;
-
-        if let Event::Key(key) = event::read()? {
-            if let KeyCode::Char('q') = key.code {
-                return Ok(());
-            }
-        }
-    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>) {
-    let size = f.size();
-    let label = Label::default().text("Test");
-    f.render_widget(label, size);
-}
--- a/examples/demo/app.rs
+++ b/examples/demo/app.rs
@@ -1,8 +1,4 @@
-use rand::{
-    distributions::{Distribution, Uniform},
-    rngs::ThreadRng,
-};
-use ratatui::widgets::ListState;
+use crate::util::{RandomSignal, SinSignal, StatefulList, TabsState};

 const TASKS: [&str; 24] = [
    "Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "Item8", "Item9", "Item10",
@@ -66,120 +62,6 @@ const EVENTS: [(&str, u64); 24] = [
    ("B24", 5),
 ];

-#[derive(Clone)]
-pub struct RandomSignal {
-    distribution: Uniform<u64>,
-    rng: ThreadRng,
-}
-
-impl RandomSignal {
-    pub fn new(lower: u64, upper: u64) -> RandomSignal {
-        RandomSignal {
-            distribution: Uniform::new(lower, upper),
-            rng: rand::thread_rng(),
-        }
-    }
-}
-
-impl Iterator for RandomSignal {
-    type Item = u64;
-    fn next(&mut self) -> Option<u64> {
-        Some(self.distribution.sample(&mut self.rng))
-    }
-}
-
-#[derive(Clone)]
-pub struct SinSignal {
-    x: f64,
-    interval: f64,
-    period: f64,
-    scale: f64,
-}
-
-impl SinSignal {
-    pub fn new(interval: f64, period: f64, scale: f64) -> SinSignal {
-        SinSignal {
-            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)
-    }
-}
-
-pub struct TabsState<'a> {
-    pub titles: Vec<&'a str>,
-    pub index: usize,
-}
-
-impl<'a> TabsState<'a> {
-    pub fn new(titles: Vec<&'a str>) -> TabsState {
-        TabsState { titles, index: 0 }
-    }
-    pub fn next(&mut self) {
-        self.index = (self.index + 1) % self.titles.len();
-    }
-
-    pub fn previous(&mut self) {
-        if self.index > 0 {
-            self.index -= 1;
-        } else {
-            self.index = self.titles.len() - 1;
-        }
-    }
-}
-
-pub struct StatefulList<T> {
-    pub state: ListState,
-    pub items: Vec<T>,
-}
-
-impl<T> StatefulList<T> {
-    pub fn with_items(items: Vec<T>) -> StatefulList<T> {
-        StatefulList {
-            state: ListState::default(),
-            items,
-        }
-    }
-
-    pub fn next(&mut self) {
-        let i = match self.state.selected() {
-            Some(i) => {
-                if i >= self.items.len() - 1 {
-                    0
-                } else {
-                    i + 1
-                }
-            }
-            None => 0,
-        };
-        self.state.select(Some(i));
-    }
-
-    pub fn previous(&mut self) {
-        let i = match self.state.selected() {
-            Some(i) => {
-                if i == 0 {
-                    self.items.len() - 1
-                } else {
-                    i - 1
-                }
-            }
-            None => 0,
-        };
-        self.state.select(Some(i));
-    }
-}
-
 pub struct Signal<S: Iterator> {
    source: S,
    pub points: Vec<S::Item>,
--- a/examples/demo/crossterm.rs
+++ b/examples/demo/crossterm.rs
@@ -1,81 +0,0 @@
-use std::{
-    error::Error,
-    io,
-    time::{Duration, Instant},
-};
-
-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEventKind},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
-    Terminal,
-};
-
-use crate::{app::App, 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 res = 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) = res {
-        println!("{err:?}");
-    }
-
-    Ok(())
-}
-
-fn run_app<B: Backend>(
-    terminal: &mut Terminal<B>,
-    mut app: App,
-    tick_rate: Duration,
-) -> io::Result<()> {
-    let mut last_tick = Instant::now();
-    loop {
-        terminal.draw(|f| ui::draw(f, &mut app))?;
-
-        let timeout = tick_rate
-            .checked_sub(last_tick.elapsed())
-            .unwrap_or_else(|| Duration::from_secs(0));
-        if crossterm::event::poll(timeout)? {
-            if let Event::Key(key) = event::read()? {
-                if key.kind == KeyEventKind::Press {
-                    match key.code {
-                        KeyCode::Char(c) => app.on_key(c),
-                        KeyCode::Left => app.on_left(),
-                        KeyCode::Up => app.on_up(),
-                        KeyCode::Right => app.on_right(),
-                        KeyCode::Down => app.on_down(),
-                        _ => {}
-                    }
-                }
-            }
-        }
-        if last_tick.elapsed() >= tick_rate {
-            app.on_tick();
-            last_tick = Instant::now();
-        }
-        if app.should_quit {
-            return Ok(());
-        }
-    }
-}
--- a/examples/demo/main.rs
+++ b/examples/demo/main.rs
@@ -1,36 +0,0 @@
-use std::{error::Error, time::Duration};
-
-use argh::FromArgs;
-
-mod app;
-#[cfg(feature = "crossterm")]
-mod crossterm;
-#[cfg(feature = "termion")]
-mod termion;
-#[cfg(feature = "termwiz")]
-mod termwiz;
-
-mod ui;
-
-/// Demo
-#[derive(Debug, FromArgs)]
-struct Cli {
-    /// time in ms between two ticks.
-    #[argh(option, default = "250")]
-    tick_rate: u64,
-    /// whether unicode symbols are used to improve the overall look of the app
-    #[argh(option, default = "true")]
-    enhanced_graphics: bool,
-}
-
-fn main() -> Result<(), Box<dyn Error>> {
-    let cli: Cli = argh::from_env();
-    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)?;
-    Ok(())
-}
--- a/examples/demo/mod.rs
+++ b/examples/demo/mod.rs
@@ -0,0 +1,3 @@
+mod app;
+pub mod ui;
+pub use app::App;
--- a/examples/demo/termion.rs
+++ b/examples/demo/termion.rs
@@ -1,85 +0,0 @@
-use std::{error::Error, io, sync::mpsc, thread, time::Duration};
-
-use ratatui::{
-    backend::{Backend, TermionBackend},
-    Terminal,
-};
-use termion::{
-    event::Key,
-    input::{MouseTerminal, TermRead},
-    raw::IntoRawMode,
-    screen::IntoAlternateScreen,
-};
-
-use crate::{app::App, ui};
-
-pub fn run(tick_rate: Duration, enhanced_graphics: bool) -> Result<(), Box<dyn Error>> {
-    // setup terminal
-    let stdout = io::stdout()
-        .into_raw_mode()
-        .unwrap()
-        .into_alternate_screen()
-        .unwrap();
-    let stdout = MouseTerminal::from(stdout);
-    let backend = TermionBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
-
-    // create app and run it
-    let app = App::new("Termion demo", enhanced_graphics);
-    run_app(&mut terminal, app, tick_rate)?;
-
-    Ok(())
-}
-
-fn run_app<B: Backend>(
-    terminal: &mut Terminal<B>,
-    mut app: App,
-    tick_rate: Duration,
-) -> Result<(), Box<dyn Error>> {
-    let events = events(tick_rate);
-    loop {
-        terminal.draw(|f| ui::draw(f, &mut app))?;
-
-        match events.recv()? {
-            Event::Input(key) => match key {
-                Key::Char(c) => app.on_key(c),
-                Key::Up => app.on_up(),
-                Key::Down => app.on_down(),
-                Key::Left => app.on_left(),
-                Key::Right => app.on_right(),
-                _ => {}
-            },
-            Event::Tick => app.on_tick(),
-        }
-        if app.should_quit {
-            return Ok(());
-        }
-    }
-}
-
-enum Event {
-    Input(Key),
-    Tick,
-}
-
-fn events(tick_rate: Duration) -> mpsc::Receiver<Event> {
-    let (tx, rx) = mpsc::channel();
-    let keys_tx = tx.clone();
-    thread::spawn(move || {
-        let stdin = io::stdin();
-        for key in stdin.keys().flatten() {
-            if let Err(err) = keys_tx.send(Event::Input(key)) {
-                eprintln!("{err}");
-                return;
-            }
-        }
-    });
-    thread::spawn(move || loop {
-        if let Err(err) = tx.send(Event::Tick) {
-            eprintln!("{err}");
-            break;
-        }
-        thread::sleep(tick_rate);
-    });
-    rx
-}
--- a/examples/demo/termwiz.rs
+++ b/examples/demo/termwiz.rs
@@ -1,76 +0,0 @@
-use std::{
-    error::Error,
-    io,
-    time::{Duration, Instant},
-};
-
-use ratatui::{backend::TermwizBackend, Terminal};
-use termwiz::{input::*, terminal::Terminal as TermwizTerminal};
-
-use crate::{app::App, ui};
-
-pub fn run(tick_rate: Duration, enhanced_graphics: bool) -> Result<(), Box<dyn Error>> {
-    let backend = TermwizBackend::new()?;
-    let mut terminal = Terminal::new(backend)?;
-    terminal.hide_cursor()?;
-
-    // create app and run it
-    let app = App::new("Termwiz Demo", enhanced_graphics);
-    let res = run_app(&mut terminal, app, tick_rate);
-
-    terminal.show_cursor()?;
-    terminal.flush()?;
-
-    if let Err(err) = res {
-        println!("{err:?}");
-    }
-
-    Ok(())
-}
-
-fn run_app(
-    terminal: &mut Terminal<TermwizBackend>,
-    mut app: App,
-    tick_rate: Duration,
-) -> io::Result<()> {
-    let mut last_tick = Instant::now();
-    loop {
-        terminal.draw(|f| ui::draw(f, &mut app))?;
-
-        let timeout = tick_rate
-            .checked_sub(last_tick.elapsed())
-            .unwrap_or_else(|| Duration::from_secs(0));
-        if let Ok(Some(input)) = terminal
-            .backend_mut()
-            .buffered_terminal_mut()
-            .terminal()
-            .poll_input(Some(timeout))
-        {
-            match input {
-                InputEvent::Key(key_code) => match key_code.key {
-                    KeyCode::UpArrow => app.on_up(),
-                    KeyCode::DownArrow => app.on_down(),
-                    KeyCode::LeftArrow => app.on_left(),
-                    KeyCode::RightArrow => app.on_right(),
-                    KeyCode::Char(c) => app.on_key(c),
-                    _ => {}
-                },
-                InputEvent::Resized { cols, rows } => {
-                    terminal
-                        .backend_mut()
-                        .buffered_terminal_mut()
-                        .resize(cols, rows);
-                }
-                _ => {}
-            }
-        }
-
-        if last_tick.elapsed() >= tick_rate {
-            app.on_tick();
-            last_tick = Instant::now();
-        }
-        if app.should_quit {
-            return Ok(());
-        }
-    }
-}
--- a/examples/demo/ui.rs
+++ b/examples/demo/ui.rs
@@ -1,19 +1,18 @@
-use ratatui::{
+use crate::demo::App;
+use tui::{
    backend::Backend,
    layout::{Constraint, Direction, Layout, Rect},
    style::{Color, Modifier, Style},
    symbols,
-    text::{Line, Span},
+    text::{Span, Spans},
+    widgets::canvas::{Canvas, Line, Map, MapResolution, Rectangle},
    widgets::{
-        canvas::{Canvas, Circle, Line as CanvasLine, Map, MapResolution, Rectangle},
        Axis, BarChart, Block, Borders, Cell, Chart, Dataset, Gauge, LineGauge, List, ListItem,
        Paragraph, Row, Sparkline, Table, Tabs, Wrap,
    },
    Frame,
 };

-use crate::app::App;
-
 pub fn draw<B: Backend>(f: &mut Frame<B>, app: &mut App) {
    let chunks = Layout::default()
        .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
@@ -22,7 +21,7 @@ pub fn draw<B: Backend>(f: &mut Frame<B>, app: &mut App) {
        .tabs
        .titles
        .iter()
-        .map(|t| Line::from(Span::styled(*t, Style::default().fg(Color::Green))))
+        .map(|t| Spans::from(Span::styled(*t, Style::default().fg(Color::Green))))
        .collect();
    let tabs = Tabs::new(titles)
        .block(Block::default().borders(Borders::ALL).title(app.title))
@@ -83,7 +82,6 @@ where
                .bg(Color::Black)
                .add_modifier(Modifier::ITALIC | Modifier::BOLD),
        )
-        .use_unicode(app.enhanced_graphics)
        .label(label)
        .ratio(app.progress);
    f.render_widget(gauge, chunks[0]);
@@ -139,7 +137,7 @@ where
                .tasks
                .items
                .iter()
-                .map(|i| ListItem::new(vec![Line::from(Span::raw(*i))]))
+                .map(|i| ListItem::new(vec![Spans::from(Span::raw(*i))]))
                .collect();
            let tasks = List::new(tasks)
                .block(Block::default().borders(Borders::ALL).title("List"))
@@ -163,8 +161,8 @@ where
                        "WARNING" => warning_style,
                        _ => info_style,
                    };
-                    let content = vec![Line::from(vec![
-                        Span::styled(format!("{level:<9}"), s),
+                    let content = vec![Spans::from(vec![
+                        Span::styled(format!("{:<9}", level), s),
                        Span::raw(evt),
                    ])];
                    ListItem::new(content)
@@ -263,9 +261,9 @@ where
    B: Backend,
 {
    let text = vec![
-        Line::from("This is a paragraph with several lines. You can change style your text the way you want"),
-        Line::from(""),
-        Line::from(vec![
+        Spans::from("This is a paragraph with several lines. You can change style your text the way you want"),
+        Spans::from(""),
+        Spans::from(vec![
            Span::from("For example: "),
            Span::styled("under", Style::default().fg(Color::Red)),
            Span::raw(" "),
@@ -274,7 +272,7 @@ where
            Span::styled("rainbow", Style::default().fg(Color::Blue)),
            Span::raw("."),
        ]),
-        Line::from(vec![
+        Spans::from(vec![
            Span::raw("Oh and if you didn't "),
            Span::styled("notice", Style::default().add_modifier(Modifier::ITALIC)),
            Span::raw(" you can "),
@@ -285,7 +283,7 @@ where
            Span::styled("text", Style::default().add_modifier(Modifier::UNDERLINED)),
            Span::raw(".")
        ]),
-        Line::from(
+        Spans::from(
            "One more thing is that it should display unicode characters: 10€"
        ),
    ];
@@ -348,15 +346,9 @@ where
                height: 10.0,
                color: Color::Yellow,
            });
-            ctx.draw(&Circle {
-                x: app.servers[2].coords.1,
-                y: app.servers[2].coords.0,
-                radius: 10.0,
-                color: Color::Green,
-            });
            for (i, s1) in app.servers.iter().enumerate() {
                for s2 in &app.servers[i + 1..] {
-                    ctx.draw(&CanvasLine {
+                    ctx.draw(&Line {
                        x1: s1.coords.1,
                        y1: s1.coords.0,
                        y2: s2.coords.0,
@@ -371,11 +363,7 @@ where
                } else {
                    Color::Red
                };
-                ctx.print(
-                    server.coords.1,
-                    server.coords.0,
-                    Span::styled("X", Style::default().fg(color)),
-                );
+                ctx.print(server.coords.1, server.coords.0, "X", color);
            }
        })
        .marker(if app.enhanced_graphics {
@@ -419,7 +407,7 @@ where
        .iter()
        .map(|c| {
            let cells = vec![
-                Cell::from(Span::raw(format!("{c:?}: "))),
+                Cell::from(Span::raw(format!("{:?}: ", c))),
                Cell::from(Span::styled("Foreground", Style::default().fg(*c))),
                Cell::from(Span::styled("Background", Style::default().bg(*c))),
            ];
--- a/examples/filter.rs
+++ b/examples/filter.rs
@@ -1,179 +0,0 @@
-use std::{error::Error, io};
-
-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
-    layout::{Constraint, Direction, Layout},
-    style::{Color, Modifier, Style},
-    text::{Line, Span, Text},
-    widgets::{Block, Borders, List, ListItem, Paragraph},
-    Frame, Terminal,
-};
-use unicode_width::UnicodeWidthStr;
-
-enum InputMode {
-    Normal,
-    Editing,
-}
-
-/// App holds the state of the application
-struct App<'a> {
-    filter: String,
-    input_mode: InputMode,
-    words: Vec<&'a str>,
-}
-
-impl<'a> App<'a> {
-    fn new(words: impl IntoIterator<Item = &'a str>) -> Self {
-        App {
-            filter: String::new(),
-            input_mode: InputMode::Normal,
-            words: words.into_iter().collect(),
-        }
-    }
-}
-
-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 app = App::new(WORDS);
-    let res = run_app(&mut terminal, app);
-
-    // 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>, mut app: App) -> io::Result<()> {
-    loop {
-        terminal.draw(|f| ui(f, &app))?;
-        if let Event::Key(key) = event::read()? {
-            match (&app.input_mode, key.code) {
-                (InputMode::Normal, KeyCode::Char('e')) => {
-                    app.input_mode = InputMode::Editing;
-                }
-                (InputMode::Normal, KeyCode::Char('q')) => {
-                    return Ok(());
-                }
-                (InputMode::Normal, _) => {}
-                (InputMode::Editing, KeyCode::Char(c)) => {
-                    app.filter.push(c);
-                }
-                (InputMode::Editing, KeyCode::Backspace) => {
-                    app.filter.pop();
-                }
-                (InputMode::Editing, KeyCode::Esc) => {
-                    app.input_mode = InputMode::Normal;
-                }
-                _ => {}
-            }
-        }
-    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .margin(2)
-        .constraints(
-            [
-                Constraint::Length(1),
-                Constraint::Length(3),
-                Constraint::Min(1),
-            ]
-            .as_ref(),
-        )
-        .split(f.size());
-
-    let (msg, style) = match app.input_mode {
-        InputMode::Normal => (
-            vec![
-                Span::raw("Press "),
-                Span::styled("q", Style::default().add_modifier(Modifier::BOLD)),
-                Span::raw(" to exit, "),
-                Span::styled("e", Style::default().add_modifier(Modifier::BOLD)),
-                Span::raw(" to start editing."),
-            ],
-            Style::default().add_modifier(Modifier::RAPID_BLINK),
-        ),
-        InputMode::Editing => (
-            vec![
-                Span::raw("Press "),
-                Span::styled("Esc", Style::default().add_modifier(Modifier::BOLD)),
-                Span::raw(" to stop editing."),
-            ],
-            Style::default(),
-        ),
-    };
-    let mut text = Text::from(Line::from(msg));
-    text.patch_style(style);
-    let help_message = Paragraph::new(text);
-    f.render_widget(help_message, chunks[0]);
-
-    let input = Paragraph::new(app.filter.clone())
-        .style(match app.input_mode {
-            InputMode::Normal => Style::default(),
-            InputMode::Editing => Style::default().fg(Color::Yellow),
-        })
-        .block(Block::default().borders(Borders::ALL).title("Input"));
-    f.render_widget(input, chunks[1]);
-    match app.input_mode {
-        InputMode::Normal =>
-            // Hide the cursor. `Frame` does this by default, so we don't need to do anything here
-            {}
-        InputMode::Editing => {
-            // Make the cursor visible and ask tui-rs to put it at the specified coordinates after
-            // rendering
-            f.set_cursor(
-                // Put cursor past the end of the input text
-                chunks[1].x + app.filter.width() as u16 + 1,
-                // Move one line down, from the border to the input line
-                chunks[1].y + 1,
-            )
-        }
-    }
-
-    let items: Vec<ListItem> = app
-        .words
-        .iter()
-        .filter(|m| m.contains(&app.filter))
-        .map(|m| {
-            let content = vec![Line::from(Span::raw(*m))];
-            ListItem::new(content)
-        })
-        .collect();
-    let list = List::new(items).block(Block::default().borders(Borders::ALL).title("Messages"));
-    f.render_widget(list, chunks[2]);
-}
-
-const WORDS: [&str; 100] = [
-    "the", "at", "there", "some", "my", "of", "be", "use", "her", "than", "and", "this", "an",
-    "would", "first", "a", "have", "each", "make", "water", "to", "from", "which", "like", "been",
-    "in", "or", "she", "him", "call", "is", "one", "do", "into", "who", "you", "had", "how",
-    "time", "oil", "that", "by", "their", "has", "its", "it", "word", "if", "look", "now", "he",
-    "but", "will", "two", "find", "was", "not", "up", "more", "long", "for", "what", "other",
-    "write", "down", "on", "all", "about", "go", "day", "are", "were", "out", "see", "did", "as",
-    "we", "many", "number", "get", "with", "when", "then", "no", "come", "his", "your", "them",
-    "way", "made", "they", "can", "these", "could", "may", "I", "said", "so", "people", "part",
-];
--- a/examples/gauge.rs
+++ b/examples/gauge.rs
@@ -1,21 +1,16 @@
-use std::{
-    error::Error,
-    io,
-    time::{Duration, Instant},
-};
+#[allow(dead_code)]
+mod util;

-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
+use crate::util::event::{Config, Event, Events};
+use std::{error::Error, io, time::Duration};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
    layout::{Constraint, Direction, Layout},
    style::{Color, Modifier, Style},
    text::Span,
    widgets::{Block, Borders, Gauge},
-    Frame, Terminal,
+    Terminal,
 };

 struct App {
@@ -35,7 +30,7 @@ impl App {
        }
    }

-    fn on_tick(&mut self) {
+    fn update(&mut self) {
        self.progress1 += 1;
        if self.progress1 > 100 {
            self.progress1 = 0;
@@ -56,112 +51,87 @@ impl App {
 }

 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);
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

-    // create app and run it
-    let tick_rate = Duration::from_millis(250);
-    let app = App::new();
-    let res = run_app(&mut terminal, app, tick_rate);
+    let events = Events::with_config(Config {
+        tick_rate: Duration::from_millis(100),
+    });

-    // restore terminal
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
+    let mut app = App::new();

-    if let Err(err) = res {
-        println!("{err:?}");
+    loop {
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(2)
+                .constraints(
+                    [
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                    ]
+                    .as_ref(),
+                )
+                .split(f.size());
+
+            let gauge = Gauge::default()
+                .block(Block::default().title("Gauge1").borders(Borders::ALL))
+                .gauge_style(Style::default().fg(Color::Yellow))
+                .percent(app.progress1);
+            f.render_widget(gauge, chunks[0]);
+
+            let label = format!("{}/100", app.progress2);
+            let gauge = Gauge::default()
+                .block(Block::default().title("Gauge2").borders(Borders::ALL))
+                .gauge_style(Style::default().fg(Color::Magenta).bg(Color::Green))
+                .percent(app.progress2)
+                .label(label);
+            f.render_widget(gauge, chunks[1]);
+
+            let label = Span::styled(
+                format!("{:.2}%", app.progress3 * 100.0),
+                Style::default()
+                    .fg(Color::Red)
+                    .add_modifier(Modifier::ITALIC | Modifier::BOLD),
+            );
+            let gauge = Gauge::default()
+                .block(Block::default().title("Gauge3").borders(Borders::ALL))
+                .gauge_style(Style::default().fg(Color::Yellow))
+                .ratio(app.progress3)
+                .label(label)
+                .use_unicode(true);
+            f.render_widget(gauge, chunks[2]);
+
+            let label = format!("{}/100", app.progress2);
+            let gauge = Gauge::default()
+                .block(Block::default().title("Gauge4"))
+                .gauge_style(
+                    Style::default()
+                        .fg(Color::Cyan)
+                        .add_modifier(Modifier::ITALIC),
+                )
+                .percent(app.progress4)
+                .label(label);
+            f.render_widget(gauge, chunks[3]);
+        })?;
+
+        match events.next()? {
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
+            Event::Tick => {
+                app.update();
+            }
+        }
    }

    Ok(())
 }
-
-fn run_app<B: Backend>(
-    terminal: &mut Terminal<B>,
-    mut app: App,
-    tick_rate: Duration,
-) -> io::Result<()> {
-    let mut last_tick = Instant::now();
-    loop {
-        terminal.draw(|f| ui(f, &app))?;
-
-        let timeout = tick_rate
-            .checked_sub(last_tick.elapsed())
-            .unwrap_or_else(|| Duration::from_secs(0));
-        if crossterm::event::poll(timeout)? {
-            if let Event::Key(key) = event::read()? {
-                if let KeyCode::Char('q') = key.code {
-                    return Ok(());
-                }
-            }
-        }
-        if last_tick.elapsed() >= tick_rate {
-            app.on_tick();
-            last_tick = Instant::now();
-        }
-    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .margin(2)
-        .constraints(
-            [
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-            ]
-            .as_ref(),
-        )
-        .split(f.size());
-
-    let gauge = Gauge::default()
-        .block(Block::default().title("Gauge1").borders(Borders::ALL))
-        .gauge_style(Style::default().fg(Color::Yellow))
-        .percent(app.progress1);
-    f.render_widget(gauge, chunks[0]);
-
-    let label = format!("{}/100", app.progress2);
-    let gauge = Gauge::default()
-        .block(Block::default().title("Gauge2").borders(Borders::ALL))
-        .gauge_style(Style::default().fg(Color::Magenta).bg(Color::Green))
-        .percent(app.progress2)
-        .label(label);
-    f.render_widget(gauge, chunks[1]);
-
-    let label = Span::styled(
-        format!("{:.2}%", app.progress3 * 100.0),
-        Style::default()
-            .fg(Color::Red)
-            .add_modifier(Modifier::ITALIC | Modifier::BOLD),
-    );
-    let gauge = Gauge::default()
-        .block(Block::default().title("Gauge3").borders(Borders::ALL))
-        .gauge_style(Style::default().fg(Color::Yellow))
-        .ratio(app.progress3)
-        .label(label)
-        .use_unicode(true);
-    f.render_widget(gauge, chunks[2]);
-
-    let label = format!("{}/100", app.progress4);
-    let gauge = Gauge::default()
-        .block(Block::default().title("Gauge4"))
-        .gauge_style(
-            Style::default()
-                .fg(Color::Cyan)
-                .add_modifier(Modifier::ITALIC),
-        )
-        .percent(app.progress4)
-        .label(label);
-    f.render_widget(gauge, chunks[3]);
-}
--- a/examples/hello_world.rs
+++ b/examples/hello_world.rs
@@ -1,80 +0,0 @@
-use std::{
-    io::{self, Stdout},
-    time::Duration,
-};
-
-use anyhow::{Context, Result};
-use crossterm::{
-    event::{self, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{backend::CrosstermBackend, widgets::Paragraph, Terminal};
-
-/// 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.
-///
-/// A more robust application would probably want to handle errors and ensure that the terminal is
-/// restored to a sane state before exiting. This example does not do that. It also does not handle
-/// events or update the application state. It just draws a greeting and exits when the user
-/// presses 'q'.
-fn main() -> Result<()> {
-    let mut terminal = setup_terminal().context("setup failed")?;
-    run(&mut terminal).context("app loop failed")?;
-    restore_terminal(&mut terminal).context("restore terminal failed")?;
-    Ok(())
-}
-
-/// Setup the terminal. This is where you would enable raw mode, enter the alternate screen, and
-/// hide the cursor. This example does not handle errors. A more robust application would probably
-/// want to handle errors and ensure that the terminal is restored to a sane state before exiting.
-fn setup_terminal() -> Result<Terminal<CrosstermBackend<Stdout>>> {
-    let mut stdout = io::stdout();
-    enable_raw_mode().context("failed to enable raw mode")?;
-    execute!(stdout, EnterAlternateScreen).context("unable to enter alternate screen")?;
-    Terminal::new(CrosstermBackend::new(stdout)).context("creating terminal failed")
-}
-
-/// Restore the terminal. This is where you disable raw mode, leave the alternate screen, and show
-/// the cursor.
-fn restore_terminal(terminal: &mut Terminal<CrosstermBackend<Stdout>>) -> Result<()> {
-    disable_raw_mode().context("failed to disable raw mode")?;
-    execute!(terminal.backend_mut(), LeaveAlternateScreen)
-        .context("unable to switch to main screen")?;
-    terminal.show_cursor().context("unable to show cursor")
-}
-
-/// 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 Terminal<CrosstermBackend<Stdout>>) -> Result<()> {
-    loop {
-        terminal.draw(crate::render_app)?;
-        if should_quit()? {
-            break;
-        }
-    }
-    Ok(())
-}
-
-/// Render the application. This is where you would draw the application UI. This example just
-/// draws a greeting.
-fn render_app(frame: &mut ratatui::Frame<CrosstermBackend<Stdout>>) {
-    let greeting = Paragraph::new("Hello World! (press 'q' to quit)");
-    frame.render_widget(greeting, frame.size());
-}
-
-/// 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 so that the application can exit in a timely
-/// manner, and to ensure that the terminal is rendered at least once every 250ms.
-fn should_quit() -> Result<bool> {
-    if event::poll(Duration::from_millis(250)).context("event poll failed")? {
-        if let Event::Key(key) = event::read().context("event read failed")? {
-            return Ok(KeyCode::Char('q') == key.code);
-        }
-    }
-    Ok(false)
-}
--- a/examples/inline.rs
+++ b/examples/inline.rs
@@ -1,291 +0,0 @@
-use std::{
-    collections::{BTreeMap, VecDeque},
-    error::Error,
-    io,
-    sync::mpsc,
-    thread,
-    time::{Duration, Instant},
-};
-
-use rand::distributions::{Distribution, Uniform};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
-    layout::{Alignment, Constraint, Direction, Layout, Rect},
-    style::{Color, Modifier, Style},
-    symbols,
-    text::{Line, Span},
-    widgets::{block::title::Title, Block, Gauge, LineGauge, List, ListItem, Paragraph, Widget},
-    Frame, Terminal, TerminalOptions, Viewport,
-};
-
-const NUM_DOWNLOADS: usize = 10;
-
-type DownloadId = usize;
-type WorkerId = usize;
-
-enum Event {
-    Input(crossterm::event::KeyEvent),
-    Tick,
-    Resize,
-    DownloadUpdate(WorkerId, DownloadId, f64),
-    DownloadDone(WorkerId, DownloadId),
-}
-
-struct Downloads {
-    pending: VecDeque<Download>,
-    in_progress: BTreeMap<WorkerId, DownloadInProgress>,
-}
-
-impl Downloads {
-    fn next(&mut self, worker_id: WorkerId) -> Option<Download> {
-        match self.pending.pop_front() {
-            Some(d) => {
-                self.in_progress.insert(
-                    worker_id,
-                    DownloadInProgress {
-                        id: d.id,
-                        started_at: Instant::now(),
-                        progress: 0.0,
-                    },
-                );
-                Some(d)
-            }
-            None => None,
-        }
-    }
-}
-
-struct DownloadInProgress {
-    id: DownloadId,
-    started_at: Instant,
-    progress: f64,
-}
-
-struct Download {
-    id: DownloadId,
-    size: usize,
-}
-
-struct Worker {
-    id: WorkerId,
-    tx: mpsc::Sender<Download>,
-}
-
-fn main() -> Result<(), Box<dyn Error>> {
-    crossterm::terminal::enable_raw_mode()?;
-    let stdout = io::stdout();
-    let backend = CrosstermBackend::new(stdout);
-    let mut terminal = Terminal::with_options(
-        backend,
-        TerminalOptions {
-            viewport: Viewport::Inline(8),
-        },
-    )?;
-
-    let (tx, rx) = mpsc::channel();
-    input_handling(tx.clone());
-    let workers = workers(tx);
-    let mut downloads = downloads();
-
-    for w in &workers {
-        let d = downloads.next(w.id).unwrap();
-        w.tx.send(d).unwrap();
-    }
-
-    run_app(&mut terminal, workers, downloads, rx)?;
-
-    crossterm::terminal::disable_raw_mode()?;
-    terminal.clear()?;
-
-    Ok(())
-}
-
-fn input_handling(tx: mpsc::Sender<Event>) {
-    let tick_rate = Duration::from_millis(200);
-    thread::spawn(move || {
-        let mut last_tick = Instant::now();
-        loop {
-            // poll for tick rate duration, if no events, sent tick event.
-            let timeout = tick_rate
-                .checked_sub(last_tick.elapsed())
-                .unwrap_or_else(|| Duration::from_secs(0));
-            if crossterm::event::poll(timeout).unwrap() {
-                match crossterm::event::read().unwrap() {
-                    crossterm::event::Event::Key(key) => tx.send(Event::Input(key)).unwrap(),
-                    crossterm::event::Event::Resize(_, _) => tx.send(Event::Resize).unwrap(),
-                    _ => {}
-                };
-            }
-            if last_tick.elapsed() >= tick_rate {
-                tx.send(Event::Tick).unwrap();
-                last_tick = Instant::now();
-            }
-        }
-    });
-}
-
-fn workers(tx: mpsc::Sender<Event>) -> Vec<Worker> {
-    (0..4)
-        .map(|id| {
-            let (worker_tx, worker_rx) = mpsc::channel::<Download>();
-            let tx = tx.clone();
-            thread::spawn(move || {
-                while let Ok(download) = worker_rx.recv() {
-                    let mut remaining = download.size;
-                    while remaining > 0 {
-                        let wait = (remaining as u64).min(10);
-                        thread::sleep(Duration::from_millis(wait * 10));
-                        remaining = remaining.saturating_sub(10);
-                        let progress = (download.size - remaining) * 100 / download.size;
-                        tx.send(Event::DownloadUpdate(id, download.id, progress as f64))
-                            .unwrap();
-                    }
-                    tx.send(Event::DownloadDone(id, download.id)).unwrap();
-                }
-            });
-            Worker { id, tx: worker_tx }
-        })
-        .collect()
-}
-
-fn downloads() -> Downloads {
-    let distribution = Uniform::new(0, 1000);
-    let mut rng = rand::thread_rng();
-    let pending = (0..NUM_DOWNLOADS)
-        .map(|id| {
-            let size = distribution.sample(&mut rng);
-            Download { id, size }
-        })
-        .collect();
-    Downloads {
-        pending,
-        in_progress: BTreeMap::new(),
-    }
-}
-
-fn run_app<B: Backend>(
-    terminal: &mut Terminal<B>,
-    workers: Vec<Worker>,
-    mut downloads: Downloads,
-    rx: mpsc::Receiver<Event>,
-) -> Result<(), Box<dyn Error>> {
-    let mut redraw = true;
-    loop {
-        if redraw {
-            terminal.draw(|f| ui(f, &downloads))?;
-        }
-        redraw = true;
-
-        match rx.recv()? {
-            Event::Input(event) => {
-                if event.code == crossterm::event::KeyCode::Char('q') {
-                    break;
-                }
-            }
-            Event::Resize => {
-                terminal.autoresize()?;
-            }
-            Event::Tick => {}
-            Event::DownloadUpdate(worker_id, _download_id, progress) => {
-                let download = downloads.in_progress.get_mut(&worker_id).unwrap();
-                download.progress = progress;
-                redraw = false
-            }
-            Event::DownloadDone(worker_id, download_id) => {
-                let download = downloads.in_progress.remove(&worker_id).unwrap();
-                terminal.insert_before(1, |buf| {
-                    Paragraph::new(Line::from(vec![
-                        Span::from("Finished "),
-                        Span::styled(
-                            format!("download {download_id}"),
-                            Style::default().add_modifier(Modifier::BOLD),
-                        ),
-                        Span::from(format!(
-                            " in {}ms",
-                            download.started_at.elapsed().as_millis()
-                        )),
-                    ]))
-                    .render(buf.area, buf);
-                })?;
-                match downloads.next(worker_id) {
-                    Some(d) => workers[worker_id].tx.send(d).unwrap(),
-                    None => {
-                        if downloads.in_progress.is_empty() {
-                            terminal.insert_before(1, |buf| {
-                                Paragraph::new("Done !").render(buf.area, buf);
-                            })?;
-                            break;
-                        }
-                    }
-                };
-            }
-        };
-    }
-    Ok(())
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>, downloads: &Downloads) {
-    let size = f.size();
-
-    let block = Block::default().title(Title::from("Progress").alignment(Alignment::Center));
-    f.render_widget(block, size);
-
-    let chunks = Layout::default()
-        .constraints(vec![Constraint::Length(2), Constraint::Length(4)])
-        .margin(1)
-        .split(size);
-
-    // total progress
-    let done = NUM_DOWNLOADS - downloads.pending.len() - downloads.in_progress.len();
-    let progress = LineGauge::default()
-        .gauge_style(Style::default().fg(Color::Blue))
-        .label(format!("{done}/{NUM_DOWNLOADS}"))
-        .ratio(done as f64 / NUM_DOWNLOADS as f64);
-    f.render_widget(progress, chunks[0]);
-
-    let chunks = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints(vec![Constraint::Percentage(20), Constraint::Percentage(80)])
-        .split(chunks[1]);
-
-    // in progress downloads
-    let items: Vec<ListItem> = downloads
-        .in_progress
-        .values()
-        .map(|download| {
-            ListItem::new(Line::from(vec![
-                Span::raw(symbols::DOT),
-                Span::styled(
-                    format!(" download {:>2}", download.id),
-                    Style::default()
-                        .fg(Color::LightGreen)
-                        .add_modifier(Modifier::BOLD),
-                ),
-                Span::raw(format!(
-                    " ({}ms)",
-                    download.started_at.elapsed().as_millis()
-                )),
-            ]))
-        })
-        .collect();
-    let list = List::new(items);
-    f.render_widget(list, chunks[0]);
-
-    for (i, (_, download)) in downloads.in_progress.iter().enumerate() {
-        let gauge = Gauge::default()
-            .gauge_style(Style::default().fg(Color::Yellow))
-            .ratio(download.progress / 100.0);
-        if chunks[1].top().saturating_add(i as u16) > size.bottom() {
-            continue;
-        }
-        f.render_widget(
-            gauge,
-            Rect {
-                x: chunks[1].left(),
-                y: chunks[1].top().saturating_add(i as u16),
-                width: chunks[1].width,
-                height: 1,
-            },
-        );
-    }
-}
--- a/examples/layout.rs
+++ b/examples/layout.rs
@@ -1,71 +1,52 @@
-use std::{error::Error, io};
+#[allow(dead_code)]
+mod util;

-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
    layout::{Constraint, Direction, Layout},
    widgets::{Block, Borders},
-    Frame, Terminal,
+    Terminal,
 };

 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);
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

-    // create app and run it
-    let res = run_app(&mut terminal);
+    let events = Events::new();

-    // restore terminal
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
+    loop {
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .constraints(
+                    [
+                        Constraint::Percentage(10),
+                        Constraint::Percentage(80),
+                        Constraint::Percentage(10),
+                    ]
+                    .as_ref(),
+                )
+                .split(f.size());

-    if let Err(err) = res {
-        println!("{err:?}");
+            let block = Block::default().title("Block").borders(Borders::ALL);
+            f.render_widget(block, chunks[0]);
+            let block = Block::default().title("Block 2").borders(Borders::ALL);
+            f.render_widget(block, chunks[2]);
+        })?;
+
+        if let Event::Input(input) = events.next()? {
+            if let Key::Char('q') = input {
+                break;
+            }
+        }
    }

    Ok(())
 }
-
-fn run_app<B: Backend>(terminal: &mut Terminal<B>) -> io::Result<()> {
-    loop {
-        terminal.draw(|f| ui(f))?;
-
-        if let Event::Key(key) = event::read()? {
-            if let KeyCode::Char('q') = key.code {
-                return Ok(());
-            }
-        }
-    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>) {
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .constraints(
-            [
-                Constraint::Percentage(10),
-                Constraint::Percentage(80),
-                Constraint::Percentage(10),
-            ]
-            .as_ref(),
-        )
-        .split(f.size());
-
-    let block = Block::default().title("Block").borders(Borders::ALL);
-    f.render_widget(block, chunks[0]);
-    let block = Block::default().title("Block 2").borders(Borders::ALL);
-    f.render_widget(block, chunks[2]);
-}
--- a/examples/list.rs
+++ b/examples/list.rs
@@ -1,72 +1,24 @@
-use std::{
-    error::Error,
-    io,
-    time::{Duration, Instant},
-};
+#[allow(dead_code)]
+mod util;

-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEventKind},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+use crate::util::{
+    event::{Event, Events},
+    StatefulList,
 };
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
    layout::{Constraint, Corner, Direction, Layout},
-    style::{Color, Modifier, Style, Stylize},
-    text::{Line, Span},
-    widgets::{Block, Borders, List, ListItem, ListState},
-    Frame, Terminal,
+    style::{Color, Modifier, Style},
+    text::{Span, Spans},
+    widgets::{Block, Borders, List, ListItem},
+    Terminal,
 };

-struct StatefulList<T> {
-    state: ListState,
-    items: Vec<T>,
-}
-
-impl<T> StatefulList<T> {
-    fn with_items(items: Vec<T>) -> StatefulList<T> {
-        StatefulList {
-            state: ListState::default(),
-            items,
-        }
-    }
-
-    fn next(&mut self) {
-        let i = match self.state.selected() {
-            Some(i) => {
-                if i >= self.items.len() - 1 {
-                    0
-                } else {
-                    i + 1
-                }
-            }
-            None => 0,
-        };
-        self.state.select(Some(i));
-    }
-
-    fn previous(&mut self) {
-        let i = match self.state.selected() {
-            Some(i) => {
-                if i == 0 {
-                    self.items.len() - 1
-                } else {
-                    i - 1
-                }
-            }
-            None => 0,
-        };
-        self.state.select(Some(i));
-    }
-
-    fn unselect(&mut self) {
-        self.state.select(None);
-    }
-}
-
-/// This struct holds the current state of the app. In particular, it has the `items` field which is
-/// a wrapper around `ListState`. Keeping track of the items state let us render the associated
-/// widget with its state and have access to features such as natural scrolling.
+/// This struct holds the current state of the app. In particular, it has the `items` field which is a wrapper
+/// around `ListState`. Keeping track of the items state let us render the associated widget with its state
+/// and have access to features such as natural scrolling.
 ///
 /// Check the event handling at the bottom to see how to change the state on incoming events.
 /// Check the drawing logic for items on how to specify the highlighting style for selected items.
@@ -138,150 +90,134 @@ impl<'a> App<'a> {

    /// Rotate through the event list.
    /// This only exists to simulate some kind of "progress"
-    fn on_tick(&mut self) {
+    fn advance(&mut self) {
        let event = self.events.remove(0);
        self.events.push(event);
    }
 }

 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);
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

-    // create app and run it
-    let tick_rate = Duration::from_millis(250);
-    let app = App::new();
-    let res = run_app(&mut terminal, app, tick_rate);
+    let events = Events::new();

-    // restore terminal
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
+    // Create a new app with some example state
+    let mut app = App::new();

-    if let Err(err) = res {
-        println!("{err:?}");
+    loop {
+        terminal.draw(|f| {
+            // Create two chunks with equal horizontal screen space
+            let chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(f.size());
+
+            // Iterate through all elements in the `items` app and append some debug text to it.
+            let items: Vec<ListItem> = app
+                .items
+                .items
+                .iter()
+                .map(|i| {
+                    let mut lines = vec![Spans::from(i.0)];
+                    for _ in 0..i.1 {
+                        lines.push(Spans::from(Span::styled(
+                            "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
+                            Style::default().add_modifier(Modifier::ITALIC),
+                        )));
+                    }
+                    ListItem::new(lines).style(Style::default().fg(Color::Black).bg(Color::White))
+                })
+                .collect();
+
+            // Create a List from all list items and highlight the currently selected one
+            let items = List::new(items)
+                .block(Block::default().borders(Borders::ALL).title("List"))
+                .highlight_style(
+                    Style::default()
+                        .bg(Color::LightGreen)
+                        .add_modifier(Modifier::BOLD),
+                )
+                .highlight_symbol(">> ");
+
+            // We can now render the item list
+            f.render_stateful_widget(items, chunks[0], &mut app.items.state);
+
+            // Let's do the same for the events.
+            // The event list doesn't have any state and only displays the current state of the list.
+            let events: Vec<ListItem> = app
+                .events
+                .iter()
+                .rev()
+                .map(|&(event, level)| {
+                    // Colorcode the level depending on its type
+                    let s = match level {
+                        "CRITICAL" => Style::default().fg(Color::Red),
+                        "ERROR" => Style::default().fg(Color::Magenta),
+                        "WARNING" => Style::default().fg(Color::Yellow),
+                        "INFO" => Style::default().fg(Color::Blue),
+                        _ => Style::default(),
+                    };
+                    // Add a example datetime and apply proper spacing between them
+                    let header = Spans::from(vec![
+                        Span::styled(format!("{:<9}", level), s),
+                        Span::raw(" "),
+                        Span::styled(
+                            "2020-01-01 10:00:00",
+                            Style::default().add_modifier(Modifier::ITALIC),
+                        ),
+                    ]);
+                    // The event gets its own line
+                    let log = Spans::from(vec![Span::raw(event)]);
+
+                    // Here several things happen:
+                    // 1. Add a `---` spacing line above the final list entry
+                    // 2. Add the Level + datetime
+                    // 3. Add a spacer line
+                    // 4. Add the actual event
+                    ListItem::new(vec![
+                        Spans::from("-".repeat(chunks[1].width as usize)),
+                        header,
+                        Spans::from(""),
+                        log,
+                    ])
+                })
+                .collect();
+            let events_list = List::new(events)
+                .block(Block::default().borders(Borders::ALL).title("List"))
+                .start_corner(Corner::BottomLeft);
+            f.render_widget(events_list, chunks[1]);
+        })?;
+
+        // This is a simple example on how to handle events
+        // 1. This breaks the loop and exits the program on `q` button press.
+        // 2. The `up`/`down` keys change the currently selected item in the App's `items` list.
+        // 3. `left` unselects the current item.
+        match events.next()? {
+            Event::Input(input) => match input {
+                Key::Char('q') => {
+                    break;
+                }
+                Key::Left => {
+                    app.items.unselect();
+                }
+                Key::Down => {
+                    app.items.next();
+                }
+                Key::Up => {
+                    app.items.previous();
+                }
+                _ => {}
+            },
+            Event::Tick => {
+                app.advance();
+            }
+        }
    }

    Ok(())
 }
-
-fn run_app<B: Backend>(
-    terminal: &mut Terminal<B>,
-    mut app: App,
-    tick_rate: Duration,
-) -> io::Result<()> {
-    let mut last_tick = Instant::now();
-    loop {
-        terminal.draw(|f| ui(f, &mut app))?;
-
-        let timeout = tick_rate
-            .checked_sub(last_tick.elapsed())
-            .unwrap_or_else(|| Duration::from_secs(0));
-        if crossterm::event::poll(timeout)? {
-            if let Event::Key(key) = event::read()? {
-                if key.kind == KeyEventKind::Press {
-                    match key.code {
-                        KeyCode::Char('q') => return Ok(()),
-                        KeyCode::Left => app.items.unselect(),
-                        KeyCode::Down => app.items.next(),
-                        KeyCode::Up => app.items.previous(),
-                        _ => {}
-                    }
-                }
-            }
-        }
-        if last_tick.elapsed() >= tick_rate {
-            app.on_tick();
-            last_tick = Instant::now();
-        }
-    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>, app: &mut App) {
-    // Create two chunks with equal horizontal screen space
-    let chunks = Layout::default()
-        .direction(Direction::Horizontal)
-        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
-        .split(f.size());
-
-    // Iterate through all elements in the `items` app and append some debug text to it.
-    let items: Vec<ListItem> = app
-        .items
-        .items
-        .iter()
-        .map(|i| {
-            let mut lines = vec![Line::from(i.0)];
-            for _ in 0..i.1 {
-                lines.push(
-                    "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
-                        .italic()
-                        .into(),
-                );
-            }
-            ListItem::new(lines).style(Style::default().fg(Color::Black).bg(Color::White))
-        })
-        .collect();
-
-    // Create a List from all list items and highlight the currently selected one
-    let items = List::new(items)
-        .block(Block::default().borders(Borders::ALL).title("List"))
-        .highlight_style(
-            Style::default()
-                .bg(Color::LightGreen)
-                .add_modifier(Modifier::BOLD),
-        )
-        .highlight_symbol(">> ");
-
-    // We can now render the item list
-    f.render_stateful_widget(items, chunks[0], &mut app.items.state);
-
-    // Let's do the same for the events.
-    // The event list doesn't have any state and only displays the current state of the list.
-    let events: Vec<ListItem> = app
-        .events
-        .iter()
-        .rev()
-        .map(|&(event, level)| {
-            // Colorcode the level depending on its type
-            let s = match level {
-                "CRITICAL" => Style::default().fg(Color::Red),
-                "ERROR" => Style::default().fg(Color::Magenta),
-                "WARNING" => Style::default().fg(Color::Yellow),
-                "INFO" => Style::default().fg(Color::Blue),
-                _ => Style::default(),
-            };
-            // Add a example datetime and apply proper spacing between them
-            let header = Line::from(vec![
-                Span::styled(format!("{level:<9}"), s),
-                " ".into(),
-                "2020-01-01 10:00:00".italic(),
-            ]);
-            // The event gets its own line
-            let log = Line::from(vec![event.into()]);
-
-            // Here several things happen:
-            // 1. Add a `---` spacing line above the final list entry
-            // 2. Add the Level + datetime
-            // 3. Add a spacer line
-            // 4. Add the actual event
-            ListItem::new(vec![
-                Line::from("-".repeat(chunks[1].width as usize)),
-                header,
-                Line::from(""),
-                log,
-            ])
-        })
-        .collect();
-    let events_list = List::new(events)
-        .block(Block::default().borders(Borders::ALL).title("List"))
-        .start_corner(Corner::BottomLeft);
-    f.render_widget(events_list, chunks[1]);
-}
--- a/examples/panic.rs
+++ b/examples/panic.rs
@@ -1,143 +0,0 @@
-//! How to use a panic hook to reset the terminal before printing the panic to
-//! the terminal.
-//!
-//! When exiting normally or when handling `Result::Err`, we can reset the
-//! terminal manually at the end of `main` just before we print the error.
-//!
-//! Because a panic interrupts the normal control flow, manually resetting the
-//! terminal at the end of `main` won't do us any good. Instead, we need to
-//! make sure to set up a panic hook that first resets the terminal before
-//! handling the panic. This both reuses the standard panic hook to ensure a
-//! consistent panic handling UX and properly resets the terminal to not
-//! distort the output.
-//!
-//! That's why this example is set up to show both situations, with and without
-//! the chained panic hook, to see the difference.
-
-#![deny(clippy::all)]
-#![warn(clippy::pedantic, clippy::nursery)]
-
-use std::{error::Error, io};
-
-use crossterm::{
-    event::{self, Event, KeyCode},
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
-    layout::Alignment,
-    text::Line,
-    widgets::{Block, Borders, Paragraph},
-    Frame, Terminal,
-};
-
-type Result<T> = std::result::Result<T, Box<dyn Error>>;
-
-#[derive(Default)]
-struct App {
-    hook_enabled: bool,
-}
-
-impl App {
-    fn chain_hook(&mut self) {
-        let original_hook = std::panic::take_hook();
-
-        std::panic::set_hook(Box::new(move |panic| {
-            reset_terminal().unwrap();
-            original_hook(panic);
-        }));
-
-        self.hook_enabled = true;
-    }
-}
-
-fn main() -> Result<()> {
-    let mut terminal = init_terminal()?;
-
-    let mut app = App::default();
-    let res = run_tui(&mut terminal, &mut app);
-
-    reset_terminal()?;
-
-    if let Err(err) = res {
-        println!("{err:?}");
-    }
-
-    Ok(())
-}
-
-/// Initializes the terminal.
-fn init_terminal() -> Result<Terminal<CrosstermBackend<io::Stdout>>> {
-    crossterm::execute!(io::stdout(), EnterAlternateScreen)?;
-    enable_raw_mode()?;
-
-    let backend = CrosstermBackend::new(io::stdout());
-
-    let mut terminal = Terminal::new(backend)?;
-    terminal.hide_cursor()?;
-
-    Ok(terminal)
-}
-
-/// Resets the terminal.
-fn reset_terminal() -> Result<()> {
-    disable_raw_mode()?;
-    crossterm::execute!(io::stdout(), LeaveAlternateScreen)?;
-
-    Ok(())
-}
-
-/// Runs the TUI loop.
-fn run_tui<B: Backend>(terminal: &mut Terminal<B>, app: &mut App) -> io::Result<()> {
-    loop {
-        terminal.draw(|f| ui(f, app))?;
-
-        if let Event::Key(key) = event::read()? {
-            match key.code {
-                KeyCode::Char('p') => {
-                    panic!("intentional demo panic");
-                }
-
-                KeyCode::Char('e') => {
-                    app.chain_hook();
-                }
-
-                _ => {
-                    return Ok(());
-                }
-            }
-        }
-    }
-}
-
-/// Render the TUI.
-fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
-    let text = vec![
-        if app.hook_enabled {
-            Line::from("HOOK IS CURRENTLY **ENABLED**")
-        } else {
-            Line::from("HOOK IS CURRENTLY **DISABLED**")
-        },
-        Line::from(""),
-        Line::from("press `p` to panic"),
-        Line::from("press `e` to enable the terminal-resetting panic hook"),
-        Line::from("press any other key to quit without panic"),
-        Line::from(""),
-        Line::from("when you panic without the chained hook,"),
-        Line::from("you will likely have to reset your terminal afterwards"),
-        Line::from("with the `reset` command"),
-        Line::from(""),
-        Line::from("with the chained panic hook enabled,"),
-        Line::from("you should see the panic report as you would without ratatui"),
-        Line::from(""),
-        Line::from("try first without the panic handler to see the difference"),
-    ];
-
-    let b = Block::default()
-        .title("Panic Handler Demo")
-        .borders(Borders::ALL);
-
-    let p = Paragraph::new(text).block(b).alignment(Alignment::Center);
-
-    f.render_widget(p, f.size());
-}
--- a/examples/paragraph.rs
+++ b/examples/paragraph.rs
@@ -1,167 +1,111 @@
-use std::{
-    error::Error,
-    io,
-    time::{Duration, Instant},
-};
+#[allow(dead_code)]
+mod util;

-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
    layout::{Alignment, Constraint, Direction, Layout},
-    style::{Color, Modifier, Style, Stylize},
-    text::{Line, Masked, Span},
+    style::{Color, Modifier, Style},
+    text::{Span, Spans},
    widgets::{Block, Borders, Paragraph, Wrap},
-    Frame, Terminal,
+    Terminal,
 };

-struct App {
-    scroll: u16,
-}
-
-impl App {
-    fn new() -> App {
-        App { scroll: 0 }
-    }
-
-    fn on_tick(&mut self) {
-        self.scroll += 1;
-        self.scroll %= 10;
-    }
-}
-
 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);
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

-    // create app and run it
-    let tick_rate = Duration::from_millis(250);
-    let app = App::new();
-    let res = run_app(&mut terminal, app, tick_rate);
+    let events = Events::new();

-    // 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>,
-    mut app: App,
-    tick_rate: Duration,
-) -> io::Result<()> {
-    let mut last_tick = Instant::now();
+    let mut scroll: u16 = 0;
    loop {
-        terminal.draw(|f| ui(f, &app))?;
+        terminal.draw(|f| {
+            let size = f.size();

-        let timeout = tick_rate
-            .checked_sub(last_tick.elapsed())
-            .unwrap_or_else(|| Duration::from_secs(0));
-        if crossterm::event::poll(timeout)? {
-            if let Event::Key(key) = event::read()? {
-                if let KeyCode::Char('q') = key.code {
-                    return Ok(());
-                }
+            // Words made "loooong" to demonstrate line breaking.
+            let s = "Veeeeeeeeeeeeeeeery    loooooooooooooooooong   striiiiiiiiiiiiiiiiiiiiiiiiiing.   ";
+            let mut long_line = s.repeat(usize::from(size.width) / s.len() + 4);
+            long_line.push('\n');
+
+            let block = Block::default()
+                .style(Style::default().bg(Color::White).fg(Color::Black));
+            f.render_widget(block, size);
+
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(5)
+                .constraints(
+                    [
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                        Constraint::Percentage(25),
+                    ]
+                    .as_ref(),
+                )
+                .split(size);
+
+            let text = vec![
+                Spans::from("This is a line "),
+                Spans::from(Span::styled("This is a line   ", Style::default().fg(Color::Red))),
+                Spans::from(Span::styled("This is a line", Style::default().bg(Color::Blue))),
+                Spans::from(Span::styled(
+                    "This is a longer line",
+                    Style::default().add_modifier(Modifier::CROSSED_OUT),
+                )),
+                Spans::from(Span::styled(&long_line, Style::default().bg(Color::Green))),
+                Spans::from(Span::styled(
+                    "This is a line",
+                    Style::default().fg(Color::Green).add_modifier(Modifier::ITALIC),
+                )),
+            ];
+
+            let create_block = |title| {
+                Block::default()
+                    .borders(Borders::ALL)
+                    .style(Style::default().bg(Color::White).fg(Color::Black))
+                    .title(Span::styled(title, Style::default().add_modifier(Modifier::BOLD)))
+            };
+            let paragraph = Paragraph::new(text.clone())
+                .style(Style::default().bg(Color::White).fg(Color::Black))
+                .block(create_block("Left, no wrap"))
+                .alignment(Alignment::Left);
+            f.render_widget(paragraph, chunks[0]);
+            let paragraph = Paragraph::new(text.clone())
+                .style(Style::default().bg(Color::White).fg(Color::Black))
+                .block(create_block("Left, wrap"))
+                .alignment(Alignment::Left)
+                .wrap(Wrap { trim: true });
+            f.render_widget(paragraph, chunks[1]);
+            let paragraph = Paragraph::new(text.clone())
+                .style(Style::default().bg(Color::White).fg(Color::Black))
+                .block(create_block("Center, wrap"))
+                .alignment(Alignment::Center)
+                .wrap(Wrap { trim: true })
+                .scroll((scroll, 0));
+            f.render_widget(paragraph, chunks[2]);
+            let paragraph = Paragraph::new(text)
+                .style(Style::default().bg(Color::White).fg(Color::Black))
+                .block(create_block("Right, wrap"))
+                .alignment(Alignment::Right)
+                .wrap(Wrap { trim: true });
+            f.render_widget(paragraph, chunks[3]);
+        })?;
+
+        scroll += 1;
+        scroll %= 10;
+
+        if let Event::Input(key) = events.next()? {
+            if key == Key::Char('q') {
+                break;
            }
        }
-        if last_tick.elapsed() >= tick_rate {
-            app.on_tick();
-            last_tick = Instant::now();
-        }
    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
-    let size = f.size();
-
-    // Words made "loooong" to demonstrate line breaking.
-    let s = "Veeeeeeeeeeeeeeeery    loooooooooooooooooong   striiiiiiiiiiiiiiiiiiiiiiiiiing.   ";
-    let mut long_line = s.repeat(usize::from(size.width) / s.len() + 4);
-    long_line.push('\n');
-
-    let block = Block::default().black();
-    f.render_widget(block, size);
-
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .margin(2)
-        .constraints(
-            [
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-            ]
-            .as_ref(),
-        )
-        .split(size);
-
-    let text = vec![
-        Line::from("This is a line "),
-        Line::from("This is a line   ".red()),
-        Line::from("This is a line".on_blue()),
-        Line::from("This is a longer line".crossed_out()),
-        Line::from(long_line.on_green()),
-        Line::from("This is a line".green().italic()),
-        Line::from(vec![
-            "Masked text: ".into(),
-            Span::styled(
-                Masked::new("password", '*'),
-                Style::default().fg(Color::Red),
-            ),
-        ]),
-    ];
-
-    let create_block = |title| {
-        Block::default()
-            .borders(Borders::ALL)
-            .style(Style::default().fg(Color::Gray))
-            .title(Span::styled(
-                title,
-                Style::default().add_modifier(Modifier::BOLD),
-            ))
-    };
-
-    let paragraph = Paragraph::new(text.clone())
-        .style(Style::default().fg(Color::Gray))
-        .block(create_block("Default alignment (Left), no wrap"));
-    f.render_widget(paragraph, chunks[0]);
-
-    let paragraph = Paragraph::new(text.clone())
-        .style(Style::default().fg(Color::Gray))
-        .block(create_block("Default alignment (Left), with wrap"))
-        .wrap(Wrap { trim: true });
-    f.render_widget(paragraph, chunks[1]);
-
-    let paragraph = Paragraph::new(text.clone())
-        .style(Style::default().fg(Color::Gray))
-        .block(create_block("Right alignment, with wrap"))
-        .alignment(Alignment::Right)
-        .wrap(Wrap { trim: true });
-    f.render_widget(paragraph, chunks[2]);
-
-    let paragraph = Paragraph::new(text)
-        .style(Style::default().fg(Color::Gray))
-        .block(create_block("Center alignment, with wrap, with scroll"))
-        .alignment(Alignment::Center)
-        .wrap(Wrap { trim: true })
-        .scroll((app.scroll, 0));
-    f.render_widget(paragraph, chunks[3]);
+    Ok(())
 }
--- a/examples/popup.rs
+++ b/examples/popup.rs
@@ -1,104 +1,20 @@
+#[allow(dead_code)]
+mod util;
+
+use crate::util::event::{Event, Events};
 use std::{error::Error, io};
-
-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEventKind},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
    layout::{Alignment, Constraint, Direction, Layout, Rect},
-    style::Stylize,
+    style::{Color, Modifier, Style},
+    text::{Span, Spans},
    widgets::{Block, Borders, Clear, Paragraph, Wrap},
-    Frame, Terminal,
+    Terminal,
 };

-struct App {
-    show_popup: bool,
-}
-
-impl App {
-    fn new() -> App {
-        App { show_popup: false }
-    }
-}
-
-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 app = App::new();
-    let res = run_app(&mut terminal, app);
-
-    // 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>, mut app: App) -> io::Result<()> {
-    loop {
-        terminal.draw(|f| ui(f, &app))?;
-
-        if let Event::Key(key) = event::read()? {
-            if key.kind == KeyEventKind::Press {
-                match key.code {
-                    KeyCode::Char('q') => return Ok(()),
-                    KeyCode::Char('p') => app.show_popup = !app.show_popup,
-                    _ => {}
-                }
-            }
-        }
-    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
-    let size = f.size();
-
-    let chunks = Layout::default()
-        .constraints([Constraint::Percentage(20), Constraint::Percentage(80)].as_ref())
-        .split(size);
-
-    let text = if app.show_popup {
-        "Press p to close the popup"
-    } else {
-        "Press p to show the popup"
-    };
-    let paragraph = Paragraph::new(text.slow_blink())
-        .alignment(Alignment::Center)
-        .wrap(Wrap { trim: true });
-    f.render_widget(paragraph, chunks[0]);
-
-    let block = Block::default()
-        .title("Content")
-        .borders(Borders::ALL)
-        .on_blue();
-    f.render_widget(block, chunks[1]);
-
-    if app.show_popup {
-        let block = Block::default().title("Popup").borders(Borders::ALL);
-        let area = centered_rect(60, 20, size);
-        f.render_widget(Clear, area); //this clears out the background
-        f.render_widget(block, area);
-    }
-}
-
-/// helper function to create a centered rect using up certain percentage of the available rect `r`
+/// helper function to create a centered rect using up
+/// certain percentage of the available rect `r`
 fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
    let popup_layout = Layout::default()
        .direction(Direction::Vertical)
@@ -124,3 +40,67 @@ fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
        )
        .split(popup_layout[1])[1]
 }
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    let events = Events::new();
+
+    loop {
+        terminal.draw(|f| {
+            let size = f.size();
+
+            let chunks = Layout::default()
+                .direction(Direction::Horizontal)
+                .constraints([Constraint::Percentage(50), Constraint::Percentage(50)].as_ref())
+                .split(size);
+
+                let s = "Veeeeeeeeeeeeeeeery    loooooooooooooooooong   striiiiiiiiiiiiiiiiiiiiiiiiiing.   ";
+                let mut long_line = s.repeat(usize::from(size.width)*usize::from(size.height)/300);
+                long_line.push('\n');
+
+            let text = vec![
+                Spans::from("This is a line "),
+                Spans::from(Span::styled("This is a line   ", Style::default().fg(Color::Red))),
+                Spans::from(Span::styled("This is a line", Style::default().bg(Color::Blue))),
+                Spans::from(Span::styled(
+                    "This is a longer line\n",
+                    Style::default().add_modifier(Modifier::CROSSED_OUT),
+                )),
+                Spans::from(Span::styled(&long_line, Style::default().bg(Color::Green))),
+                Spans::from(Span::styled(
+                    "This is a line\n",
+                    Style::default().fg(Color::Green).add_modifier(Modifier::ITALIC),
+                )),
+            ];
+
+            let paragraph = Paragraph::new(text.clone())
+                .block(Block::default().title("Left Block").borders(Borders::ALL))
+                .alignment(Alignment::Left).wrap(Wrap { trim: true });
+            f.render_widget(paragraph, chunks[0]);
+
+            let paragraph = Paragraph::new(text)
+                .block(Block::default().title("Right Block").borders(Borders::ALL))
+                .alignment(Alignment::Left).wrap(Wrap { trim: true });
+            f.render_widget(paragraph, chunks[1]);
+
+            let block = Block::default().title("Popup").borders(Borders::ALL);
+            let area = centered_rect(60, 20, size);
+            f.render_widget(Clear, area); //this clears out the background
+            f.render_widget(block, area);
+        })?;
+
+        if let Event::Input(input) = events.next()? {
+            if let Key::Char('q') = input {
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}
--- a/examples/rustbox_demo.rs
+++ b/examples/rustbox_demo.rs
@@ -0,0 +1,68 @@
+mod demo;
+#[allow(dead_code)]
+mod util;
+
+use crate::demo::{ui, App};
+use argh::FromArgs;
+use rustbox::keyboard::Key;
+use std::{
+    error::Error,
+    time::{Duration, Instant},
+};
+use tui::{backend::RustboxBackend, Terminal};
+
+/// Rustbox demo
+#[derive(Debug, FromArgs)]
+struct Cli {
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
+    tick_rate: u64,
+    /// whether unicode symbols are used to improve the overall look of the app
+    #[argh(option, default = "true")]
+    enhanced_graphics: bool,
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
+
+    let backend = RustboxBackend::new()?;
+    let mut terminal = Terminal::new(backend)?;
+
+    let mut app = App::new("Rustbox demo", cli.enhanced_graphics);
+
+    let mut last_tick = Instant::now();
+    let tick_rate = Duration::from_millis(cli.tick_rate);
+    loop {
+        terminal.draw(|f| ui::draw(f, &mut app))?;
+        if let Ok(rustbox::Event::KeyEvent(key)) =
+            terminal.backend().rustbox().peek_event(tick_rate, false)
+        {
+            match key {
+                Key::Char(c) => {
+                    app.on_key(c);
+                }
+                Key::Up => {
+                    app.on_up();
+                }
+                Key::Down => {
+                    app.on_down();
+                }
+                Key::Left => {
+                    app.on_left();
+                }
+                Key::Right => {
+                    app.on_right();
+                }
+                _ => {}
+            }
+        }
+        if last_tick.elapsed() > tick_rate {
+            app.on_tick();
+            last_tick = Instant::now();
+        }
+        if app.should_quit {
+            break;
+        }
+    }
+    Ok(())
+}
--- a/examples/scrollbar.rs
+++ b/examples/scrollbar.rs
@@ -1,255 +0,0 @@
-use std::{
-    error::Error,
-    io,
-    time::{Duration, Instant},
-};
-
-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
-    layout::{Alignment, Constraint, Direction, Layout, Margin},
-    style::{Color, Modifier, Style, Stylize},
-    text::{Line, Masked, Span},
-    widgets::{
-        scrollbar, Block, Borders, Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState,
-    },
-    Frame, Terminal,
-};
-
-#[derive(Default)]
-struct App {
-    pub vertical_scroll_state: ScrollbarState,
-    pub horizontal_scroll_state: ScrollbarState,
-    pub vertical_scroll: usize,
-    pub horizontal_scroll: usize,
-}
-
-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 tick_rate = Duration::from_millis(250);
-    let app = App::default();
-    let res = 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) = res {
-        println!("{err:?}");
-    }
-
-    Ok(())
-}
-
-fn run_app<B: Backend>(
-    terminal: &mut Terminal<B>,
-    mut app: App,
-    tick_rate: Duration,
-) -> io::Result<()> {
-    let mut last_tick = Instant::now();
-    loop {
-        terminal.draw(|f| ui(f, &mut app))?;
-
-        let timeout = tick_rate
-            .checked_sub(last_tick.elapsed())
-            .unwrap_or_else(|| Duration::from_secs(0));
-        if crossterm::event::poll(timeout)? {
-            if let Event::Key(key) = event::read()? {
-                match key.code {
-                    KeyCode::Char('q') => return Ok(()),
-                    KeyCode::Char('j') => {
-                        app.vertical_scroll = app.vertical_scroll.saturating_add(1);
-                        app.vertical_scroll_state = app
-                            .vertical_scroll_state
-                            .position(app.vertical_scroll as u16);
-                    }
-                    KeyCode::Char('k') => {
-                        app.vertical_scroll = app.vertical_scroll.saturating_sub(1);
-                        app.vertical_scroll_state = app
-                            .vertical_scroll_state
-                            .position(app.vertical_scroll as u16);
-                    }
-                    KeyCode::Char('h') => {
-                        app.horizontal_scroll = app.horizontal_scroll.saturating_sub(1);
-                        app.horizontal_scroll_state = app
-                            .horizontal_scroll_state
-                            .position(app.horizontal_scroll as u16);
-                    }
-                    KeyCode::Char('l') => {
-                        app.horizontal_scroll = app.horizontal_scroll.saturating_add(1);
-                        app.horizontal_scroll_state = app
-                            .horizontal_scroll_state
-                            .position(app.horizontal_scroll as u16);
-                    }
-                    _ => {}
-                }
-            }
-        }
-        if last_tick.elapsed() >= tick_rate {
-            last_tick = Instant::now();
-        }
-    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>, app: &mut App) {
-    let size = f.size();
-
-    // Words made "loooong" to demonstrate line breaking.
-    let s = "Veeeeeeeeeeeeeeeery    loooooooooooooooooong   striiiiiiiiiiiiiiiiiiiiiiiiiing.   ";
-    let mut long_line = s.repeat(usize::from(size.width) / s.len() + 4);
-    long_line.push('\n');
-
-    let block = Block::default().black();
-    f.render_widget(block, size);
-
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .margin(2)
-        .constraints(
-            [
-                Constraint::Min(1),
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-            ]
-            .as_ref(),
-        )
-        .split(size);
-
-    let text = vec![
-        Line::from("This is a line "),
-        Line::from("This is a line   ".red()),
-        Line::from("This is a line".on_dark_gray()),
-        Line::from("This is a longer line".crossed_out()),
-        Line::from(long_line.reset()),
-        Line::from("This is a line".reset()),
-        Line::from(vec![
-            Span::raw("Masked text: "),
-            Span::styled(
-                Masked::new("password", '*'),
-                Style::default().fg(Color::Red),
-            ),
-        ]),
-        Line::from("This is a line "),
-        Line::from("This is a line   ".red()),
-        Line::from("This is a line".on_dark_gray()),
-        Line::from("This is a longer line".crossed_out()),
-        Line::from(long_line.reset()),
-        Line::from("This is a line".reset()),
-        Line::from(vec![
-            Span::raw("Masked text: "),
-            Span::styled(
-                Masked::new("password", '*'),
-                Style::default().fg(Color::Red),
-            ),
-        ]),
-    ];
-    app.vertical_scroll_state = app.vertical_scroll_state.content_length(text.len() as u16);
-    app.horizontal_scroll_state = app
-        .horizontal_scroll_state
-        .content_length(long_line.len() as u16);
-
-    let create_block = |title| {
-        Block::default()
-            .borders(Borders::ALL)
-            .gray()
-            .title(Span::styled(
-                title,
-                Style::default().add_modifier(Modifier::BOLD),
-            ))
-    };
-
-    let title = Block::default()
-        .title("Use h j k l to scroll ◄ ▲ ▼ ►")
-        .title_alignment(Alignment::Center);
-    f.render_widget(title, chunks[0]);
-
-    let paragraph = Paragraph::new(text.clone())
-        .gray()
-        .block(create_block("Vertical scrollbar with arrows"))
-        .scroll((app.vertical_scroll as u16, 0));
-    f.render_widget(paragraph, chunks[1]);
-    f.render_stateful_widget(
-        Scrollbar::default()
-            .orientation(ScrollbarOrientation::VerticalRight)
-            .begin_symbol(Some("↑"))
-            .end_symbol(Some("↓")),
-        chunks[1],
-        &mut app.vertical_scroll_state,
-    );
-
-    let paragraph = Paragraph::new(text.clone())
-        .gray()
-        .block(create_block(
-            "Vertical scrollbar without arrows and mirrored",
-        ))
-        .scroll((app.vertical_scroll as u16, 0));
-    f.render_widget(paragraph, chunks[2]);
-    f.render_stateful_widget(
-        Scrollbar::default()
-            .orientation(ScrollbarOrientation::VerticalLeft)
-            .symbols(scrollbar::VERTICAL)
-            .begin_symbol(None)
-            .end_symbol(None),
-        chunks[2].inner(&Margin {
-            vertical: 1,
-            horizontal: 0,
-        }),
-        &mut app.vertical_scroll_state,
-    );
-
-    let paragraph = Paragraph::new(text.clone())
-        .gray()
-        .block(create_block(
-            "Horizontal scrollbar with only begin arrow & custom thumb symbol",
-        ))
-        .scroll((0, app.horizontal_scroll as u16));
-    f.render_widget(paragraph, chunks[3]);
-    f.render_stateful_widget(
-        Scrollbar::default()
-            .orientation(ScrollbarOrientation::HorizontalBottom)
-            .thumb_symbol("🬋")
-            .end_symbol(None),
-        chunks[3].inner(&Margin {
-            vertical: 0,
-            horizontal: 1,
-        }),
-        &mut app.horizontal_scroll_state,
-    );
-
-    let paragraph = Paragraph::new(text.clone())
-        .gray()
-        .block(create_block(
-            "Horizontal scrollbar without arrows & custom thumb and track symbol",
-        ))
-        .scroll((0, app.horizontal_scroll as u16));
-    f.render_widget(paragraph, chunks[4]);
-    f.render_stateful_widget(
-        Scrollbar::default()
-            .orientation(ScrollbarOrientation::HorizontalBottom)
-            .thumb_symbol("░")
-            .track_symbol("─"),
-        chunks[4].inner(&Margin {
-            vertical: 0,
-            horizontal: 1,
-        }),
-        &mut app.horizontal_scroll_state,
-    );
-}
--- a/examples/sparkline.rs
+++ b/examples/sparkline.rs
@@ -1,48 +1,20 @@
-use std::{
-    error::Error,
-    io,
-    time::{Duration, Instant},
-};
+#[allow(dead_code)]
+mod util;

-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+use crate::util::{
+    event::{Event, Events},
+    RandomSignal,
 };
-use rand::{
-    distributions::{Distribution, Uniform},
-    rngs::ThreadRng,
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
    layout::{Constraint, Direction, Layout},
    style::{Color, Style},
    widgets::{Block, Borders, Sparkline},
-    Frame, Terminal,
+    Terminal,
 };

-#[derive(Clone)]
-pub struct RandomSignal {
-    distribution: Uniform<u64>,
-    rng: ThreadRng,
-}
-
-impl RandomSignal {
-    pub fn new(lower: u64, upper: u64) -> RandomSignal {
-        RandomSignal {
-            distribution: Uniform::new(lower, upper),
-            rng: rand::thread_rng(),
-        }
-    }
-}
-
-impl Iterator for RandomSignal {
-    type Item = u64;
-    fn next(&mut self) -> Option<u64> {
-        Some(self.distribution.sample(&mut self.rng))
-    }
-}
-
 struct App {
    signal: RandomSignal,
    data1: Vec<u64>,
@@ -64,7 +36,7 @@ impl App {
        }
    }

-    fn on_tick(&mut self) {
+    fn update(&mut self) {
        let value = self.signal.next().unwrap();
        self.data1.pop();
        self.data1.insert(0, value);
@@ -78,100 +50,75 @@ impl App {
 }

 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);
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

-    // create app and run it
-    let tick_rate = Duration::from_millis(250);
-    let app = App::new();
-    let res = run_app(&mut terminal, app, tick_rate);
+    // Setup event handlers
+    let events = Events::new();

-    // restore terminal
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
+    // Create default app state
+    let mut app = App::new();

-    if let Err(err) = res {
-        println!("{err:?}");
+    loop {
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(2)
+                .constraints(
+                    [
+                        Constraint::Length(3),
+                        Constraint::Length(3),
+                        Constraint::Length(7),
+                        Constraint::Min(0),
+                    ]
+                    .as_ref(),
+                )
+                .split(f.size());
+            let sparkline = Sparkline::default()
+                .block(
+                    Block::default()
+                        .title("Data1")
+                        .borders(Borders::LEFT | Borders::RIGHT),
+                )
+                .data(&app.data1)
+                .style(Style::default().fg(Color::Yellow));
+            f.render_widget(sparkline, chunks[0]);
+            let sparkline = Sparkline::default()
+                .block(
+                    Block::default()
+                        .title("Data2")
+                        .borders(Borders::LEFT | Borders::RIGHT),
+                )
+                .data(&app.data2)
+                .style(Style::default().bg(Color::Green));
+            f.render_widget(sparkline, chunks[1]);
+            // Multiline
+            let sparkline = Sparkline::default()
+                .block(
+                    Block::default()
+                        .title("Data3")
+                        .borders(Borders::LEFT | Borders::RIGHT),
+                )
+                .data(&app.data3)
+                .style(Style::default().fg(Color::Red));
+            f.render_widget(sparkline, chunks[2]);
+        })?;
+
+        match events.next()? {
+            Event::Input(input) => {
+                if input == Key::Char('q') {
+                    break;
+                }
+            }
+            Event::Tick => {
+                app.update();
+            }
+        }
    }

    Ok(())
 }
-
-fn run_app<B: Backend>(
-    terminal: &mut Terminal<B>,
-    mut app: App,
-    tick_rate: Duration,
-) -> io::Result<()> {
-    let mut last_tick = Instant::now();
-    loop {
-        terminal.draw(|f| ui(f, &app))?;
-
-        let timeout = tick_rate
-            .checked_sub(last_tick.elapsed())
-            .unwrap_or_else(|| Duration::from_secs(0));
-        if crossterm::event::poll(timeout)? {
-            if let Event::Key(key) = event::read()? {
-                if let KeyCode::Char('q') = key.code {
-                    return Ok(());
-                }
-            }
-        }
-        if last_tick.elapsed() >= tick_rate {
-            app.on_tick();
-            last_tick = Instant::now();
-        }
-    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .margin(2)
-        .constraints(
-            [
-                Constraint::Length(3),
-                Constraint::Length(3),
-                Constraint::Length(7),
-                Constraint::Min(0),
-            ]
-            .as_ref(),
-        )
-        .split(f.size());
-    let sparkline = Sparkline::default()
-        .block(
-            Block::default()
-                .title("Data1")
-                .borders(Borders::LEFT | Borders::RIGHT),
-        )
-        .data(&app.data1)
-        .style(Style::default().fg(Color::Yellow));
-    f.render_widget(sparkline, chunks[0]);
-    let sparkline = Sparkline::default()
-        .block(
-            Block::default()
-                .title("Data2")
-                .borders(Borders::LEFT | Borders::RIGHT),
-        )
-        .data(&app.data2)
-        .style(Style::default().bg(Color::Green));
-    f.render_widget(sparkline, chunks[1]);
-    // Multiline
-    let sparkline = Sparkline::default()
-        .block(
-            Block::default()
-                .title("Data3")
-                .borders(Borders::LEFT | Borders::RIGHT),
-        )
-        .data(&app.data3)
-        .style(Style::default().fg(Color::Red));
-    f.render_widget(sparkline, chunks[2]);
-}
--- a/examples/table.rs
+++ b/examples/table.rs
@@ -1,26 +1,25 @@
-use std::{error::Error, io};
+#[allow(dead_code)]
+mod util;

-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEventKind},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
    layout::{Constraint, Layout},
    style::{Color, Modifier, Style},
    widgets::{Block, Borders, Cell, Row, Table, TableState},
-    Frame, Terminal,
+    Terminal,
 };

-struct App<'a> {
+pub struct StatefulTable<'a> {
    state: TableState,
    items: Vec<Vec<&'a str>>,
 }

-impl<'a> App<'a> {
-    fn new() -> App<'a> {
-        App {
+impl<'a> StatefulTable<'a> {
+    fn new() -> StatefulTable<'a> {
+        StatefulTable {
            state: TableState::default(),
            items: vec![
                vec!["Row11", "Row12", "Row13"],
@@ -75,84 +74,72 @@ impl<'a> App<'a> {
 }

 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);
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

-    // create app and run it
-    let app = App::new();
-    let res = run_app(&mut terminal, app);
+    let events = Events::new();

-    // restore terminal
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
+    let mut table = StatefulTable::new();

-    if let Err(err) = res {
-        println!("{err:?}");
+    // Input
+    loop {
+        terminal.draw(|f| {
+            let rects = Layout::default()
+                .constraints([Constraint::Percentage(100)].as_ref())
+                .margin(5)
+                .split(f.size());
+
+            let selected_style = Style::default().add_modifier(Modifier::REVERSED);
+            let normal_style = Style::default().bg(Color::Blue);
+            let header_cells = ["Header1", "Header2", "Header3"]
+                .iter()
+                .map(|h| Cell::from(*h).style(Style::default().fg(Color::Red)));
+            let header = Row::new(header_cells)
+                .style(normal_style)
+                .height(1)
+                .bottom_margin(1);
+            let rows = table.items.iter().map(|item| {
+                let height = item
+                    .iter()
+                    .map(|content| content.chars().filter(|c| *c == '\n').count())
+                    .max()
+                    .unwrap_or(0)
+                    + 1;
+                let cells = item.iter().map(|c| Cell::from(*c));
+                Row::new(cells).height(height as u16).bottom_margin(1)
+            });
+            let t = Table::new(rows)
+                .header(header)
+                .block(Block::default().borders(Borders::ALL).title("Table"))
+                .highlight_style(selected_style)
+                .highlight_symbol(">> ")
+                .widths(&[
+                    Constraint::Percentage(50),
+                    Constraint::Length(30),
+                    Constraint::Max(10),
+                ]);
+            f.render_stateful_widget(t, rects[0], &mut table.state);
+        })?;
+
+        if let Event::Input(key) = events.next()? {
+            match key {
+                Key::Char('q') => {
+                    break;
+                }
+                Key::Down => {
+                    table.next();
+                }
+                Key::Up => {
+                    table.previous();
+                }
+                _ => {}
+            }
+        };
    }

    Ok(())
 }
-
-fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<()> {
-    loop {
-        terminal.draw(|f| ui(f, &mut app))?;
-
-        if let Event::Key(key) = event::read()? {
-            if key.kind == KeyEventKind::Press {
-                match key.code {
-                    KeyCode::Char('q') => return Ok(()),
-                    KeyCode::Down => app.next(),
-                    KeyCode::Up => app.previous(),
-                    _ => {}
-                }
-            }
-        }
-    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>, app: &mut App) {
-    let rects = Layout::default()
-        .constraints([Constraint::Percentage(100)].as_ref())
-        .margin(5)
-        .split(f.size());
-
-    let selected_style = Style::default().add_modifier(Modifier::REVERSED);
-    let normal_style = Style::default().bg(Color::Blue);
-    let header_cells = ["Header1", "Header2", "Header3"]
-        .iter()
-        .map(|h| Cell::from(*h).style(Style::default().fg(Color::Red)));
-    let header = Row::new(header_cells)
-        .style(normal_style)
-        .height(1)
-        .bottom_margin(1);
-    let rows = app.items.iter().map(|item| {
-        let height = item
-            .iter()
-            .map(|content| content.chars().filter(|c| *c == '\n').count())
-            .max()
-            .unwrap_or(0)
-            + 1;
-        let cells = item.iter().map(|c| Cell::from(*c));
-        Row::new(cells).height(height as u16).bottom_margin(1)
-    });
-    let t = Table::new(rows)
-        .header(header)
-        .block(Block::default().borders(Borders::ALL).title("Table"))
-        .highlight_style(selected_style)
-        .highlight_symbol(">> ")
-        .widths(&[
-            Constraint::Percentage(50),
-            Constraint::Length(30),
-            Constraint::Min(10),
-        ]);
-    f.render_stateful_widget(t, rects[0], &mut app.state);
-}
--- a/examples/tabs.rs
+++ b/examples/tabs.rs
@@ -1,124 +1,94 @@
-use std::{error::Error, io};
+#[allow(dead_code)]
+mod util;

-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEventKind},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+use crate::util::{
+    event::{Event, Events},
+    TabsState,
 };
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
    layout::{Constraint, Direction, Layout},
-    style::{Color, Modifier, Style, Stylize},
-    text::Line,
+    style::{Color, Modifier, Style},
+    text::{Span, Spans},
    widgets::{Block, Borders, Tabs},
-    Frame, Terminal,
+    Terminal,
 };

 struct App<'a> {
-    pub titles: Vec<&'a str>,
-    pub index: usize,
-}
-
-impl<'a> App<'a> {
-    fn new() -> App<'a> {
-        App {
-            titles: vec!["Tab0", "Tab1", "Tab2", "Tab3"],
-            index: 0,
-        }
-    }
-
-    pub fn next(&mut self) {
-        self.index = (self.index + 1) % self.titles.len();
-    }
-
-    pub fn previous(&mut self) {
-        if self.index > 0 {
-            self.index -= 1;
-        } else {
-            self.index = self.titles.len() - 1;
-        }
-    }
+    tabs: TabsState<'a>,
 }

 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);
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

-    // create app and run it
-    let app = App::new();
-    let res = run_app(&mut terminal, app);
+    let events = Events::new();

-    // restore terminal
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
+    // App
+    let mut app = App {
+        tabs: TabsState::new(vec!["Tab0", "Tab1", "Tab2", "Tab3"]),
+    };

-    if let Err(err) = res {
-        println!("{err:?}");
-    }
-
-    Ok(())
-}
-
-fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<()> {
+    // Main loop
    loop {
-        terminal.draw(|f| ui(f, &app))?;
+        terminal.draw(|f| {
+            let size = f.size();
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(5)
+                .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
+                .split(size);

-        if let Event::Key(key) = event::read()? {
-            if key.kind == KeyEventKind::Press {
-                match key.code {
-                    KeyCode::Char('q') => return Ok(()),
-                    KeyCode::Right => app.next(),
-                    KeyCode::Left => app.previous(),
-                    _ => {}
+            let block = Block::default().style(Style::default().bg(Color::White).fg(Color::Black));
+            f.render_widget(block, size);
+            let titles = app
+                .tabs
+                .titles
+                .iter()
+                .map(|t| {
+                    let (first, rest) = t.split_at(1);
+                    Spans::from(vec![
+                        Span::styled(first, Style::default().fg(Color::Yellow)),
+                        Span::styled(rest, Style::default().fg(Color::Green)),
+                    ])
+                })
+                .collect();
+            let tabs = Tabs::new(titles)
+                .block(Block::default().borders(Borders::ALL).title("Tabs"))
+                .select(app.tabs.index)
+                .style(Style::default().fg(Color::Cyan))
+                .highlight_style(
+                    Style::default()
+                        .add_modifier(Modifier::BOLD)
+                        .bg(Color::Black),
+                );
+            f.render_widget(tabs, chunks[0]);
+            let inner = match app.tabs.index {
+                0 => Block::default().title("Inner 0").borders(Borders::ALL),
+                1 => Block::default().title("Inner 1").borders(Borders::ALL),
+                2 => Block::default().title("Inner 2").borders(Borders::ALL),
+                3 => Block::default().title("Inner 3").borders(Borders::ALL),
+                _ => unreachable!(),
+            };
+            f.render_widget(inner, chunks[1]);
+        })?;
+
+        if let Event::Input(input) = events.next()? {
+            match input {
+                Key::Char('q') => {
+                    break;
                }
+                Key::Right => app.tabs.next(),
+                Key::Left => app.tabs.previous(),
+                _ => {}
            }
        }
    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
-    let size = f.size();
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .margin(5)
-        .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
-        .split(size);
-
-    let block = Block::default().on_white().black();
-    f.render_widget(block, size);
-    let titles = app
-        .titles
-        .iter()
-        .map(|t| {
-            let (first, rest) = t.split_at(1);
-            Line::from(vec![first.yellow(), rest.green()])
-        })
-        .collect();
-    let tabs = Tabs::new(titles)
-        .block(Block::default().borders(Borders::ALL).title("Tabs"))
-        .select(app.index)
-        .style(Style::default().fg(Color::Cyan))
-        .highlight_style(
-            Style::default()
-                .add_modifier(Modifier::BOLD)
-                .bg(Color::Black),
-        );
-    f.render_widget(tabs, chunks[0]);
-    let inner = match app.index {
-        0 => Block::default().title("Inner 0").borders(Borders::ALL),
-        1 => Block::default().title("Inner 1").borders(Borders::ALL),
-        2 => Block::default().title("Inner 2").borders(Borders::ALL),
-        3 => Block::default().title("Inner 3").borders(Borders::ALL),
-        _ => unreachable!(),
-    };
-    f.render_widget(inner, chunks[1]);
+    Ok(())
 }
--- a/examples/termion_demo.rs
+++ b/examples/termion_demo.rs
@@ -0,0 +1,72 @@
+mod demo;
+#[allow(dead_code)]
+mod util;
+
+use crate::{
+    demo::{ui, App},
+    util::event::{Config, Event, Events},
+};
+use argh::FromArgs;
+use std::{error::Error, io, time::Duration};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{backend::TermionBackend, Terminal};
+
+/// Termion demo
+#[derive(Debug, FromArgs)]
+struct Cli {
+    /// time in ms between two ticks.
+    #[argh(option, default = "250")]
+    tick_rate: u64,
+    /// whether unicode symbols are used to improve the overall look of the app
+    #[argh(option, default = "true")]
+    enhanced_graphics: bool,
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let cli: Cli = argh::from_env();
+
+    let events = Events::with_config(Config {
+        tick_rate: Duration::from_millis(cli.tick_rate),
+        ..Config::default()
+    });
+
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+
+    let mut app = App::new("Termion demo", cli.enhanced_graphics);
+    loop {
+        terminal.draw(|f| ui::draw(f, &mut app))?;
+
+        match events.next()? {
+            Event::Input(key) => match key {
+                Key::Char(c) => {
+                    app.on_key(c);
+                }
+                Key::Up => {
+                    app.on_up();
+                }
+                Key::Down => {
+                    app.on_down();
+                }
+                Key::Left => {
+                    app.on_left();
+                }
+                Key::Right => {
+                    app.on_right();
+                }
+                _ => {}
+            },
+            Event::Tick => {
+                app.on_tick();
+            }
+        }
+        if app.should_quit {
+            break;
+        }
+    }
+
+    Ok(())
+}
--- a/examples/user_input.rs
+++ b/examples/user_input.rs
@@ -1,5 +1,3 @@
-use std::{error::Error, io};
-
 /// A simple example demonstrating how to handle user input. This is
 /// a bit out of the scope of the library as it does not provide any
 /// input handling out of the box. However, it may helps some to get
@@ -11,18 +9,20 @@ use std::{error::Error, io};
 ///   * Pressing Backspace erases a character
 ///   * Pressing Enter pushes the current input in the history of previous
 ///   messages
-use crossterm::{
-    event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode, KeyEventKind},
-    execute,
-    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-};
-use ratatui::{
-    backend::{Backend, CrosstermBackend},
+
+#[allow(dead_code)]
+mod util;
+
+use crate::util::event::{Event, Events};
+use std::{error::Error, io};
+use termion::{event::Key, input::MouseTerminal, raw::IntoRawMode, screen::AlternateScreen};
+use tui::{
+    backend::TermionBackend,
    layout::{Constraint, Direction, Layout},
-    style::{Color, Modifier, Style, Stylize},
-    text::{Line, Span, Text},
+    style::{Color, Modifier, Style},
+    text::{Span, Spans, Text},
    widgets::{Block, Borders, List, ListItem, Paragraph},
-    Frame, Terminal,
+    Terminal,
 };
 use unicode_width::UnicodeWidthStr;

@@ -52,144 +52,128 @@ impl Default for App {
 }

 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);
+    // Terminal initialization
+    let stdout = io::stdout().into_raw_mode()?;
+    let stdout = MouseTerminal::from(stdout);
+    let stdout = AlternateScreen::from(stdout);
+    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

-    // create app and run it
-    let app = App::default();
-    let res = run_app(&mut terminal, app);
+    // Setup event handlers
+    let events = Events::new();

-    // restore terminal
-    disable_raw_mode()?;
-    execute!(
-        terminal.backend_mut(),
-        LeaveAlternateScreen,
-        DisableMouseCapture
-    )?;
-    terminal.show_cursor()?;
+    // Create default app state
+    let mut app = App::default();

-    if let Err(err) = res {
-        println!("{err:?}");
-    }
-
-    Ok(())
-}
-
-fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<()> {
    loop {
-        terminal.draw(|f| ui(f, &app))?;
+        // Draw UI
+        terminal.draw(|f| {
+            let chunks = Layout::default()
+                .direction(Direction::Vertical)
+                .margin(2)
+                .constraints(
+                    [
+                        Constraint::Length(1),
+                        Constraint::Length(3),
+                        Constraint::Min(1),
+                    ]
+                    .as_ref(),
+                )
+                .split(f.size());

-        if let Event::Key(key) = event::read()? {
+            let (msg, style) = match app.input_mode {
+                InputMode::Normal => (
+                    vec![
+                        Span::raw("Press "),
+                        Span::styled("q", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::raw(" to exit, "),
+                        Span::styled("e", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::raw(" to start editing."),
+                    ],
+                    Style::default().add_modifier(Modifier::RAPID_BLINK),
+                ),
+                InputMode::Editing => (
+                    vec![
+                        Span::raw("Press "),
+                        Span::styled("Esc", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::raw(" to stop editing, "),
+                        Span::styled("Enter", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::raw(" to record the message"),
+                    ],
+                    Style::default(),
+                ),
+            };
+            let mut text = Text::from(Spans::from(msg));
+            text.patch_style(style);
+            let help_message = Paragraph::new(text);
+            f.render_widget(help_message, chunks[0]);
+
+            let input = Paragraph::new(app.input.as_ref())
+                .style(match app.input_mode {
+                    InputMode::Normal => Style::default(),
+                    InputMode::Editing => Style::default().fg(Color::Yellow),
+                })
+                .block(Block::default().borders(Borders::ALL).title("Input"));
+            f.render_widget(input, chunks[1]);
            match app.input_mode {
-                InputMode::Normal => match key.code {
-                    KeyCode::Char('e') => {
+                InputMode::Normal =>
+                    // Hide the cursor. `Frame` does this by default, so we don't need to do anything here
+                    {}
+
+                InputMode::Editing => {
+                    // Make the cursor visible and ask tui-rs to put it at the specified coordinates after rendering
+                    f.set_cursor(
+                        // Put cursor past the end of the input text
+                        chunks[1].x + app.input.width() as u16 + 1,
+                        // Move one line down, from the border to the input line
+                        chunks[1].y + 1,
+                    )
+                }
+            }
+
+            let messages: Vec<ListItem> = app
+                .messages
+                .iter()
+                .enumerate()
+                .map(|(i, m)| {
+                    let content = vec![Spans::from(Span::raw(format!("{}: {}", i, m)))];
+                    ListItem::new(content)
+                })
+                .collect();
+            let messages =
+                List::new(messages).block(Block::default().borders(Borders::ALL).title("Messages"));
+            f.render_widget(messages, chunks[2]);
+        })?;
+
+        // Handle input
+        if let Event::Input(input) = events.next()? {
+            match app.input_mode {
+                InputMode::Normal => match input {
+                    Key::Char('e') => {
                        app.input_mode = InputMode::Editing;
                    }
-                    KeyCode::Char('q') => {
-                        return Ok(());
+                    Key::Char('q') => {
+                        break;
                    }
                    _ => {}
                },
-                InputMode::Editing if key.kind == KeyEventKind::Press => match key.code {
-                    KeyCode::Enter => {
+                InputMode::Editing => match input {
+                    Key::Char('\n') => {
                        app.messages.push(app.input.drain(..).collect());
                    }
-                    KeyCode::Char(c) => {
+                    Key::Char(c) => {
                        app.input.push(c);
                    }
-                    KeyCode::Backspace => {
+                    Key::Backspace => {
                        app.input.pop();
                    }
-                    KeyCode::Esc => {
+                    Key::Esc => {
                        app.input_mode = InputMode::Normal;
                    }
                    _ => {}
                },
-                _ => {}
            }
        }
    }
-}
-
-fn ui<B: Backend>(f: &mut Frame<B>, app: &App) {
-    let chunks = Layout::default()
-        .direction(Direction::Vertical)
-        .margin(2)
-        .constraints(
-            [
-                Constraint::Length(1),
-                Constraint::Length(3),
-                Constraint::Min(1),
-            ]
-            .as_ref(),
-        )
-        .split(f.size());
-
-    let (msg, style) = match app.input_mode {
-        InputMode::Normal => (
-            vec![
-                "Press ".into(),
-                "q".bold(),
-                " to exist, ".into(),
-                "e".bold(),
-                " to start editing.".bold(),
-            ],
-            Style::default().add_modifier(Modifier::RAPID_BLINK),
-        ),
-        InputMode::Editing => (
-            vec![
-                "Press ".into(),
-                "Esc".bold(),
-                " to stop editing, ".into(),
-                "Enter".bold(),
-                " to record the message".into(),
-            ],
-            Style::default(),
-        ),
-    };
-    let mut text = Text::from(Line::from(msg));
-    text.patch_style(style);
-    let help_message = Paragraph::new(text);
-    f.render_widget(help_message, chunks[0]);
-
-    let input = Paragraph::new(app.input.as_str())
-        .style(match app.input_mode {
-            InputMode::Normal => Style::default(),
-            InputMode::Editing => Style::default().fg(Color::Yellow),
-        })
-        .block(Block::default().borders(Borders::ALL).title("Input"));
-    f.render_widget(input, chunks[1]);
-    match app.input_mode {
-        InputMode::Normal =>
-            // Hide the cursor. `Frame` does this by default, so we don't need to do anything here
-            {}
-
-        InputMode::Editing => {
-            // Make the cursor visible and ask ratatui to put it at the specified coordinates after
-            // rendering
-            f.set_cursor(
-                // Put cursor past the end of the input text
-                chunks[1].x + app.input.width() as u16 + 1,
-                // Move one line down, from the border to the input line
-                chunks[1].y + 1,
-            )
-        }
-    }
-
-    let messages: Vec<ListItem> = app
-        .messages
-        .iter()
-        .enumerate()
-        .map(|(i, m)| {
-            let content = Line::from(Span::raw(format!("{i}: {m}")));
-            ListItem::new(content)
-        })
-        .collect();
-    let messages =
-        List::new(messages).block(Block::default().borders(Borders::ALL).title("Messages"));
-    f.render_widget(messages, chunks[2]);
+    Ok(())
 }
--- a/examples/util/event.rs
+++ b/examples/util/event.rs
@@ -0,0 +1,75 @@
+use std::io;
+use std::sync::mpsc;
+use std::thread;
+use std::time::Duration;
+
+use termion::event::Key;
+use termion::input::TermRead;
+
+pub enum Event<I> {
+    Input(I),
+    Tick,
+}
+
+/// A small event handler that wrap termion input and tick events. Each event
+/// type is handled in its own thread and returned to a common `Receiver`
+pub struct Events {
+    rx: mpsc::Receiver<Event<Key>>,
+    input_handle: thread::JoinHandle<()>,
+    tick_handle: thread::JoinHandle<()>,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Config {
+    pub tick_rate: Duration,
+}
+
+impl Default for Config {
+    fn default() -> Config {
+        Config {
+            tick_rate: Duration::from_millis(250),
+        }
+    }
+}
+
+impl Events {
+    pub fn new() -> Events {
+        Events::with_config(Config::default())
+    }
+
+    pub fn with_config(config: Config) -> Events {
+        let (tx, rx) = mpsc::channel();
+        let input_handle = {
+            let tx = tx.clone();
+            thread::spawn(move || {
+                let stdin = io::stdin();
+                for evt in stdin.keys() {
+                    if let Ok(key) = evt {
+                        if let Err(err) = tx.send(Event::Input(key)) {
+                            eprintln!("{}", err);
+                            return;
+                        }
+                    }
+                }
+            })
+        };
+        let tick_handle = {
+            thread::spawn(move || loop {
+                if let Err(err) = tx.send(Event::Tick) {
+                    eprintln!("{}", err);
+                    break;
+                }
+                thread::sleep(config.tick_rate);
+            })
+        };
+        Events {
+            rx,
+            input_handle,
+            tick_handle,
+        }
+    }
+
+    pub fn next(&self) -> Result<Event<Key>, mpsc::RecvError> {
+        self.rx.recv()
+    }
+}
--- a/examples/util/mod.rs
+++ b/examples/util/mod.rs
@@ -0,0 +1,131 @@
+#[cfg(feature = "termion")]
+pub mod event;
+
+use rand::distributions::{Distribution, Uniform};
+use rand::rngs::ThreadRng;
+use tui::widgets::ListState;
+
+#[derive(Clone)]
+pub struct RandomSignal {
+    distribution: Uniform<u64>,
+    rng: ThreadRng,
+}
+
+impl RandomSignal {
+    pub fn new(lower: u64, upper: u64) -> RandomSignal {
+        RandomSignal {
+            distribution: Uniform::new(lower, upper),
+            rng: rand::thread_rng(),
+        }
+    }
+}
+
+impl Iterator for RandomSignal {
+    type Item = u64;
+    fn next(&mut self) -> Option<u64> {
+        Some(self.distribution.sample(&mut self.rng))
+    }
+}
+
+#[derive(Clone)]
+pub struct SinSignal {
+    x: f64,
+    interval: f64,
+    period: f64,
+    scale: f64,
+}
+
+impl SinSignal {
+    pub fn new(interval: f64, period: f64, scale: f64) -> SinSignal {
+        SinSignal {
+            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)
+    }
+}
+
+pub struct TabsState<'a> {
+    pub titles: Vec<&'a str>,
+    pub index: usize,
+}
+
+impl<'a> TabsState<'a> {
+    pub fn new(titles: Vec<&'a str>) -> TabsState {
+        TabsState { titles, index: 0 }
+    }
+    pub fn next(&mut self) {
+        self.index = (self.index + 1) % self.titles.len();
+    }
+
+    pub fn previous(&mut self) {
+        if self.index > 0 {
+            self.index -= 1;
+        } else {
+            self.index = self.titles.len() - 1;
+        }
+    }
+}
+
+pub struct StatefulList<T> {
+    pub state: ListState,
+    pub items: Vec<T>,
+}
+
+impl<T> StatefulList<T> {
+    pub fn new() -> StatefulList<T> {
+        StatefulList {
+            state: ListState::default(),
+            items: Vec::new(),
+        }
+    }
+
+    pub fn with_items(items: Vec<T>) -> StatefulList<T> {
+        StatefulList {
+            state: ListState::default(),
+            items,
+        }
+    }
+
+    pub fn next(&mut self) {
+        let i = match self.state.selected() {
+            Some(i) => {
+                if i >= self.items.len() - 1 {
+                    0
+                } else {
+                    i + 1
+                }
+            }
+            None => 0,
+        };
+        self.state.select(Some(i));
+    }
+
+    pub fn previous(&mut self) {
+        let i = match self.state.selected() {
+            Some(i) => {
+                if i == 0 {
+                    self.items.len() - 1
+                } else {
+                    i - 1
+                }
+            }
+            None => 0,
+        };
+        self.state.select(Some(i));
+    }
+
+    pub fn unselect(&mut self) {
+        self.state.select(None);
+    }
+}
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -1,5 +0,0 @@
-# configuration for https://rust-lang.github.io/rustfmt/
-group_imports = "StdExternalCrate"
-imports_granularity = "Crate"
-wrap_comments = true
-comment_width = 100
--- a/src/backend/crossterm.rs
+++ b/src/backend/crossterm.rs
@@ -1,12 +1,9 @@
-//! This module provides the `CrosstermBackend` implementation for the `Backend` trait.
-//! It uses the `crossterm` crate to interact with the terminal.
-//!
-//!
-//! [`Backend`]: trait.Backend.html
-//! [`CrosstermBackend`]: struct.CrosstermBackend.html
-
-use std::io::{self, Write};
-
+use crate::{
+    backend::Backend,
+    buffer::Cell,
+    layout::Rect,
+    style::{Color, Modifier},
+};
 use crossterm::{
    cursor::{Hide, MoveTo, Show},
    execute, queue,
@@ -14,34 +11,10 @@ use crossterm::{
        Attribute as CAttribute, Color as CColor, Print, SetAttribute, SetBackgroundColor,
        SetForegroundColor,
    },
-    terminal::{self, Clear},
+    terminal::{self, Clear, ClearType},
 };
+use std::io::{self, Write};

-use crate::{
-    backend::{Backend, ClearType},
-    buffer::Cell,
-    layout::Rect,
-    style::{Color, Modifier},
-};
-
-/// A backend implementation using the `crossterm` crate.
-///
-/// The `CrosstermBackend` struct is a wrapper around a type implementing `Write`, which
-/// is used to send commands to the terminal. It provides methods for drawing content,
-/// manipulating the cursor, and clearing the terminal screen.
-///
-/// # Example
-///
-/// ```rust
-/// use ratatui::backend::{Backend, CrosstermBackend};
-///
-/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-/// let buffer = std::io::stdout();
-/// let mut backend = CrosstermBackend::new(buffer);
-/// backend.clear()?;
-/// # Ok(())
-/// # }
-/// ```
 pub struct CrosstermBackend<W: Write> {
    buffer: W,
 }
@@ -50,7 +23,6 @@ impl<W> CrosstermBackend<W>
 where
    W: Write,
 {
-    /// Creates a new `CrosstermBackend` with the given buffer.
    pub fn new(buffer: W) -> CrosstermBackend<W> {
        CrosstermBackend { buffer }
    }
@@ -60,12 +32,10 @@ impl<W> Write for CrosstermBackend<W>
 where
    W: Write,
 {
-    /// Writes a buffer of bytes to the underlying buffer.
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        self.buffer.write(buf)
    }

-    /// Flushes the underlying buffer.
    fn flush(&mut self) -> io::Result<()> {
        self.buffer.flush()
    }
@@ -137,27 +107,7 @@ where
    }

    fn clear(&mut self) -> io::Result<()> {
-        self.clear_region(ClearType::All)
-    }
-
-    fn clear_region(&mut self, clear_type: ClearType) -> io::Result<()> {
-        map_error(execute!(
-            self.buffer,
-            Clear(match clear_type {
-                ClearType::All => crossterm::terminal::ClearType::All,
-                ClearType::AfterCursor => crossterm::terminal::ClearType::FromCursorDown,
-                ClearType::BeforeCursor => crossterm::terminal::ClearType::FromCursorUp,
-                ClearType::CurrentLine => crossterm::terminal::ClearType::CurrentLine,
-                ClearType::UntilNewLine => crossterm::terminal::ClearType::UntilNewLine,
-            })
-        ))
-    }
-
-    fn append_lines(&mut self, n: u16) -> io::Result<()> {
-        for _ in 0..n {
-            map_error(queue!(self.buffer, Print("\n")))?;
-        }
-        self.buffer.flush()
+        map_error(execute!(self.buffer, Clear(ClearType::All)))
    }

    fn size(&self) -> io::Result<Rect> {
@@ -202,9 +152,6 @@ impl From<Color> for CColor {
    }
 }

-/// The `ModifierDiff` struct is used to calculate the difference between two `Modifier`
-/// values. This is useful when updating the terminal display, as it allows for more
-/// efficient updates by only sending the necessary changes.
 #[derive(Debug)]
 struct ModifierDiff {
    pub from: Modifier,
--- a/src/backend/curses.rs
+++ b/src/backend/curses.rs
@@ -0,0 +1,280 @@
+use std::io;
+
+use crate::backend::Backend;
+use crate::buffer::Cell;
+use crate::layout::Rect;
+use crate::style::{Color, Modifier};
+use crate::symbols::{bar, block};
+#[cfg(unix)]
+use crate::symbols::{line, DOT};
+#[cfg(unix)]
+use pancurses::{chtype, ToChtype};
+use unicode_segmentation::UnicodeSegmentation;
+
+pub struct CursesBackend {
+    curses: easycurses::EasyCurses,
+}
+
+impl CursesBackend {
+    pub fn new() -> Option<CursesBackend> {
+        let curses = easycurses::EasyCurses::initialize_system()?;
+        Some(CursesBackend { curses })
+    }
+
+    pub fn with_curses(curses: easycurses::EasyCurses) -> CursesBackend {
+        CursesBackend { curses }
+    }
+
+    pub fn get_curses(&self) -> &easycurses::EasyCurses {
+        &self.curses
+    }
+
+    pub fn get_curses_mut(&mut self) -> &mut easycurses::EasyCurses {
+        &mut self.curses
+    }
+}
+
+impl Backend for CursesBackend {
+    fn draw<'a, I>(&mut self, content: I) -> io::Result<()>
+    where
+        I: Iterator<Item = (u16, u16, &'a Cell)>,
+    {
+        let mut last_col = 0;
+        let mut last_row = 0;
+        let mut fg = Color::Reset;
+        let mut bg = Color::Reset;
+        let mut modifier = Modifier::empty();
+        let mut curses_style = CursesStyle {
+            fg: easycurses::Color::White,
+            bg: easycurses::Color::Black,
+        };
+        let mut update_color = false;
+        for (col, row, cell) in content {
+            if row != last_row || col != last_col + 1 {
+                self.curses.move_rc(i32::from(row), i32::from(col));
+            }
+            last_col = col;
+            last_row = row;
+            if cell.modifier != modifier {
+                apply_modifier_diff(&mut self.curses.win, modifier, cell.modifier);
+                modifier = cell.modifier;
+            };
+            if cell.fg != fg {
+                update_color = true;
+                if let Some(ccolor) = cell.fg.into() {
+                    fg = cell.fg;
+                    curses_style.fg = ccolor;
+                } else {
+                    fg = Color::White;
+                    curses_style.fg = easycurses::Color::White;
+                }
+            };
+            if cell.bg != bg {
+                update_color = true;
+                if let Some(ccolor) = cell.bg.into() {
+                    bg = cell.bg;
+                    curses_style.bg = ccolor;
+                } else {
+                    bg = Color::Black;
+                    curses_style.bg = easycurses::Color::Black;
+                }
+            };
+            if update_color {
+                self.curses
+                    .set_color_pair(easycurses::ColorPair::new(curses_style.fg, curses_style.bg));
+            };
+            update_color = false;
+            draw(&mut self.curses, cell.symbol.as_str());
+        }
+        self.curses.win.attrset(pancurses::Attribute::Normal);
+        self.curses.set_color_pair(easycurses::ColorPair::new(
+            easycurses::Color::White,
+            easycurses::Color::Black,
+        ));
+        Ok(())
+    }
+    fn hide_cursor(&mut self) -> io::Result<()> {
+        self.curses
+            .set_cursor_visibility(easycurses::CursorVisibility::Invisible);
+        Ok(())
+    }
+    fn show_cursor(&mut self) -> io::Result<()> {
+        self.curses
+            .set_cursor_visibility(easycurses::CursorVisibility::Visible);
+        Ok(())
+    }
+    fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
+        let (y, x) = self.curses.get_cursor_rc();
+        Ok((x as u16, y as u16))
+    }
+    fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
+        self.curses.move_rc(i32::from(y), i32::from(x));
+        Ok(())
+    }
+    fn clear(&mut self) -> io::Result<()> {
+        self.curses.clear();
+        // self.curses.refresh();
+        Ok(())
+    }
+    fn size(&self) -> Result<Rect, io::Error> {
+        let (nrows, ncols) = self.curses.get_row_col_count();
+        Ok(Rect::new(0, 0, ncols as u16, nrows as u16))
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        self.curses.refresh();
+        Ok(())
+    }
+}
+
+struct CursesStyle {
+    fg: easycurses::Color,
+    bg: easycurses::Color,
+}
+
+#[cfg(unix)]
+/// Deals with lack of unicode support for ncurses on unix
+fn draw(curses: &mut easycurses::EasyCurses, symbol: &str) {
+    for grapheme in symbol.graphemes(true) {
+        let ch = match grapheme {
+            line::TOP_RIGHT => pancurses::ACS_URCORNER(),
+            line::VERTICAL => pancurses::ACS_VLINE(),
+            line::HORIZONTAL => pancurses::ACS_HLINE(),
+            line::TOP_LEFT => pancurses::ACS_ULCORNER(),
+            line::BOTTOM_RIGHT => pancurses::ACS_LRCORNER(),
+            line::BOTTOM_LEFT => pancurses::ACS_LLCORNER(),
+            line::VERTICAL_LEFT => pancurses::ACS_RTEE(),
+            line::VERTICAL_RIGHT => pancurses::ACS_LTEE(),
+            line::HORIZONTAL_DOWN => pancurses::ACS_TTEE(),
+            line::HORIZONTAL_UP => pancurses::ACS_BTEE(),
+            block::FULL => pancurses::ACS_BLOCK(),
+            block::SEVEN_EIGHTHS => pancurses::ACS_BLOCK(),
+            block::THREE_QUARTERS => pancurses::ACS_BLOCK(),
+            block::FIVE_EIGHTHS => pancurses::ACS_BLOCK(),
+            block::HALF => pancurses::ACS_BLOCK(),
+            block::THREE_EIGHTHS => ' ' as chtype,
+            block::ONE_QUARTER => ' ' as chtype,
+            block::ONE_EIGHTH => ' ' as chtype,
+            bar::SEVEN_EIGHTHS => pancurses::ACS_BLOCK(),
+            bar::THREE_QUARTERS => pancurses::ACS_BLOCK(),
+            bar::FIVE_EIGHTHS => pancurses::ACS_BLOCK(),
+            bar::HALF => pancurses::ACS_BLOCK(),
+            bar::THREE_EIGHTHS => pancurses::ACS_S9(),
+            bar::ONE_QUARTER => pancurses::ACS_S9(),
+            bar::ONE_EIGHTH => pancurses::ACS_S9(),
+            DOT => pancurses::ACS_BULLET(),
+            unicode_char => {
+                if unicode_char.is_ascii() {
+                    let mut chars = unicode_char.chars();
+                    if let Some(ch) = chars.next() {
+                        ch.to_chtype()
+                    } else {
+                        pancurses::ACS_BLOCK()
+                    }
+                } else {
+                    pancurses::ACS_BLOCK()
+                }
+            }
+        };
+        curses.win.addch(ch);
+    }
+}
+
+#[cfg(windows)]
+fn draw(curses: &mut easycurses::EasyCurses, symbol: &str) {
+    for grapheme in symbol.graphemes(true) {
+        let ch = match grapheme {
+            block::SEVEN_EIGHTHS => block::FULL,
+            block::THREE_QUARTERS => block::FULL,
+            block::FIVE_EIGHTHS => block::HALF,
+            block::THREE_EIGHTHS => block::HALF,
+            block::ONE_QUARTER => block::HALF,
+            block::ONE_EIGHTH => " ",
+            bar::SEVEN_EIGHTHS => bar::FULL,
+            bar::THREE_QUARTERS => bar::FULL,
+            bar::FIVE_EIGHTHS => bar::HALF,
+            bar::THREE_EIGHTHS => bar::HALF,
+            bar::ONE_QUARTER => bar::HALF,
+            bar::ONE_EIGHTH => " ",
+            ch => ch,
+        };
+        // curses.win.addch(ch);
+        curses.print(ch);
+    }
+}
+
+impl From<Color> for Option<easycurses::Color> {
+    fn from(color: Color) -> Option<easycurses::Color> {
+        match color {
+            Color::Reset => None,
+            Color::Black => Some(easycurses::Color::Black),
+            Color::Red | Color::LightRed => Some(easycurses::Color::Red),
+            Color::Green | Color::LightGreen => Some(easycurses::Color::Green),
+            Color::Yellow | Color::LightYellow => Some(easycurses::Color::Yellow),
+            Color::Magenta | Color::LightMagenta => Some(easycurses::Color::Magenta),
+            Color::Cyan | Color::LightCyan => Some(easycurses::Color::Cyan),
+            Color::White | Color::Gray | Color::DarkGray => Some(easycurses::Color::White),
+            Color::Blue | Color::LightBlue => Some(easycurses::Color::Blue),
+            Color::Indexed(_) => None,
+            Color::Rgb(_, _, _) => None,
+        }
+    }
+}
+
+fn apply_modifier_diff(win: &mut pancurses::Window, from: Modifier, to: Modifier) {
+    remove_modifier(win, from - to);
+    add_modifier(win, to - from);
+}
+
+fn remove_modifier(win: &mut pancurses::Window, remove: Modifier) {
+    if remove.contains(Modifier::BOLD) {
+        win.attroff(pancurses::Attribute::Bold);
+    }
+    if remove.contains(Modifier::DIM) {
+        win.attroff(pancurses::Attribute::Dim);
+    }
+    if remove.contains(Modifier::ITALIC) {
+        win.attroff(pancurses::Attribute::Italic);
+    }
+    if remove.contains(Modifier::UNDERLINED) {
+        win.attroff(pancurses::Attribute::Underline);
+    }
+    if remove.contains(Modifier::SLOW_BLINK) || remove.contains(Modifier::RAPID_BLINK) {
+        win.attroff(pancurses::Attribute::Blink);
+    }
+    if remove.contains(Modifier::REVERSED) {
+        win.attroff(pancurses::Attribute::Reverse);
+    }
+    if remove.contains(Modifier::HIDDEN) {
+        win.attroff(pancurses::Attribute::Invisible);
+    }
+    if remove.contains(Modifier::CROSSED_OUT) {
+        win.attroff(pancurses::Attribute::Strikeout);
+    }
+}
+
+fn add_modifier(win: &mut pancurses::Window, add: Modifier) {
+    if add.contains(Modifier::BOLD) {
+        win.attron(pancurses::Attribute::Bold);
+    }
+    if add.contains(Modifier::DIM) {
+        win.attron(pancurses::Attribute::Dim);
+    }
+    if add.contains(Modifier::ITALIC) {
+        win.attron(pancurses::Attribute::Italic);
+    }
+    if add.contains(Modifier::UNDERLINED) {
+        win.attron(pancurses::Attribute::Underline);
+    }
+    if add.contains(Modifier::SLOW_BLINK) || add.contains(Modifier::RAPID_BLINK) {
+        win.attron(pancurses::Attribute::Blink);
+    }
+    if add.contains(Modifier::REVERSED) {
+        win.attron(pancurses::Attribute::Reverse);
+    }
+    if add.contains(Modifier::HIDDEN) {
+        win.attron(pancurses::Attribute::Invisible);
+    }
+    if add.contains(Modifier::CROSSED_OUT) {
+        win.attron(pancurses::Attribute::Strikeout);
+    }
+}
--- a/src/backend/mod.rs
+++ b/src/backend/mod.rs
@@ -1,33 +1,12 @@
-//! This module provides the backend implementations for different terminal libraries.
-//! It defines the [`Backend`] trait which is used to abstract over the specific
-//! terminal library being used.
-//!
-//! The following terminal libraries are supported:
-//! - Crossterm (with the `crossterm` feature)
-//! - Termion (with the `termion` feature)
-//! - Termwiz (with the `termwiz` feature)
-//!
-//! Additionally, a [`TestBackend`] is provided for testing purposes.
-//!
-//! # Example
-//!
-//! ```rust
-//! use ratatui::backend::{Backend, CrosstermBackend};
-//!
-//! # fn main() -> Result<(), Box<dyn std::error::Error>> {
-//! let buffer = std::io::stdout();
-//! let mut backend = CrosstermBackend::new(buffer);
-//! backend.clear()?;
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! [`Backend`]: trait.Backend.html
-//! [`TestBackend`]: struct.TestBackend.html
-
 use std::io;

-use crate::{buffer::Cell, layout::Rect};
+use crate::buffer::Cell;
+use crate::layout::Rect;
+
+#[cfg(feature = "rustbox")]
+mod rustbox;
+#[cfg(feature = "rustbox")]
+pub use self::rustbox::RustboxBackend;

 #[cfg(feature = "termion")]
 mod termion;
@@ -39,79 +18,23 @@ mod crossterm;
 #[cfg(feature = "crossterm")]
 pub use self::crossterm::CrosstermBackend;

-#[cfg(feature = "termwiz")]
-mod termwiz;
-#[cfg(feature = "termwiz")]
-pub use self::termwiz::TermwizBackend;
+#[cfg(feature = "curses")]
+mod curses;
+#[cfg(feature = "curses")]
+pub use self::curses::CursesBackend;

 mod test;
 pub use self::test::TestBackend;

-/// Enum representing the different types of clearing operations that can be performed
-/// on the terminal screen.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ClearType {
-    All,
-    AfterCursor,
-    BeforeCursor,
-    CurrentLine,
-    UntilNewLine,
-}
-
-/// The `Backend` trait provides an abstraction over different terminal libraries.
-/// It defines the methods required to draw content, manipulate the cursor, and
-/// clear the terminal screen.
 pub trait Backend {
-    /// Draw the given content to the terminal screen.
-    ///
-    /// The content is provided as an iterator over `(u16, u16, &Cell)` tuples,
-    /// where the first two elements represent the x and y coordinates, and the
-    /// third element is a reference to the [`Cell`] to be drawn.
    fn draw<'a, I>(&mut self, content: I) -> Result<(), io::Error>
    where
        I: Iterator<Item = (u16, u16, &'a Cell)>;
-
-    /// Insert `n` line breaks to the terminal screen.
-    ///
-    /// This method is optional and may not be implemented by all backends.
-    fn append_lines(&mut self, _n: u16) -> io::Result<()> {
-        Ok(())
-    }
-
-    /// Hide the cursor on the terminal screen.
    fn hide_cursor(&mut self) -> Result<(), io::Error>;
-
-    /// Show the cursor on the terminal screen.
    fn show_cursor(&mut self) -> Result<(), io::Error>;
-
-    /// Get the current cursor position on the terminal screen.
    fn get_cursor(&mut self) -> Result<(u16, u16), io::Error>;
-
-    /// Set the cursor position on the terminal screen to the given x and y coordinates.
    fn set_cursor(&mut self, x: u16, y: u16) -> Result<(), io::Error>;
-
-    /// Clears the whole terminal screen
    fn clear(&mut self) -> Result<(), io::Error>;
-
-    /// Clears a specific region of the terminal specified by the [`ClearType`] parameter
-    ///
-    /// This method is optional and may not be implemented by all backends.
-    fn clear_region(&mut self, clear_type: ClearType) -> Result<(), io::Error> {
-        match clear_type {
-            ClearType::All => self.clear(),
-            ClearType::AfterCursor
-            | ClearType::BeforeCursor
-            | ClearType::CurrentLine
-            | ClearType::UntilNewLine => Err(io::Error::new(
-                io::ErrorKind::Other,
-                format!("clear_type [{clear_type:?}] not supported with this backend"),
-            )),
-        }
-    }
-
-    /// Get the size of the terminal screen as a [`Rect`].
    fn size(&self) -> Result<Rect, io::Error>;
-
-    /// Flush any buffered content to the terminal screen.
    fn flush(&mut self) -> Result<(), io::Error>;
 }
--- a/src/backend/rustbox.rs
+++ b/src/backend/rustbox.rs
@@ -0,0 +1,123 @@
+use crate::{
+    backend::Backend,
+    buffer::Cell,
+    layout::Rect,
+    style::{Color, Modifier},
+};
+use std::io;
+
+pub struct RustboxBackend {
+    rustbox: rustbox::RustBox,
+}
+
+impl RustboxBackend {
+    pub fn new() -> Result<RustboxBackend, rustbox::InitError> {
+        let rustbox = rustbox::RustBox::init(Default::default())?;
+        Ok(RustboxBackend { rustbox })
+    }
+
+    pub fn with_rustbox(instance: rustbox::RustBox) -> RustboxBackend {
+        RustboxBackend { rustbox: instance }
+    }
+
+    pub fn rustbox(&self) -> &rustbox::RustBox {
+        &self.rustbox
+    }
+}
+
+impl Backend for RustboxBackend {
+    fn draw<'a, I>(&mut self, content: I) -> Result<(), io::Error>
+    where
+        I: Iterator<Item = (u16, u16, &'a Cell)>,
+    {
+        for (x, y, cell) in content {
+            self.rustbox.print(
+                x as usize,
+                y as usize,
+                cell.modifier.into(),
+                cell.fg.into(),
+                cell.bg.into(),
+                &cell.symbol,
+            );
+        }
+        Ok(())
+    }
+    fn hide_cursor(&mut self) -> Result<(), io::Error> {
+        Ok(())
+    }
+    fn show_cursor(&mut self) -> Result<(), io::Error> {
+        Ok(())
+    }
+    fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
+        Err(io::Error::from(io::ErrorKind::Other))
+    }
+    fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
+        self.rustbox.set_cursor(x as isize, y as isize);
+        Ok(())
+    }
+    fn clear(&mut self) -> Result<(), io::Error> {
+        self.rustbox.clear();
+        Ok(())
+    }
+    fn size(&self) -> Result<Rect, io::Error> {
+        let term_width = self.rustbox.width();
+        let term_height = self.rustbox.height();
+        let max = u16::max_value();
+        Ok(Rect::new(
+            0,
+            0,
+            if term_width > usize::from(max) {
+                max
+            } else {
+                term_width as u16
+            },
+            if term_height > usize::from(max) {
+                max
+            } else {
+                term_height as u16
+            },
+        ))
+    }
+    fn flush(&mut self) -> Result<(), io::Error> {
+        self.rustbox.present();
+        Ok(())
+    }
+}
+
+fn rgb_to_byte(r: u8, g: u8, b: u8) -> u16 {
+    u16::from((r & 0xC0) + ((g & 0xE0) >> 2) + ((b & 0xE0) >> 5))
+}
+
+impl From<Color> for rustbox::Color {
+    fn from(color: Color) -> rustbox::Color {
+        match color {
+            Color::Reset => rustbox::Color::Default,
+            Color::Black | Color::Gray | Color::DarkGray => rustbox::Color::Black,
+            Color::Red | Color::LightRed => rustbox::Color::Red,
+            Color::Green | Color::LightGreen => rustbox::Color::Green,
+            Color::Yellow | Color::LightYellow => rustbox::Color::Yellow,
+            Color::Magenta | Color::LightMagenta => rustbox::Color::Magenta,
+            Color::Cyan | Color::LightCyan => rustbox::Color::Cyan,
+            Color::White => rustbox::Color::White,
+            Color::Blue | Color::LightBlue => rustbox::Color::Blue,
+            Color::Indexed(i) => rustbox::Color::Byte(u16::from(i)),
+            Color::Rgb(r, g, b) => rustbox::Color::Byte(rgb_to_byte(r, g, b)),
+        }
+    }
+}
+
+impl From<Modifier> for rustbox::Style {
+    fn from(modifier: Modifier) -> rustbox::Style {
+        let mut result = rustbox::Style::empty();
+        if modifier.contains(Modifier::BOLD) {
+            result.insert(rustbox::RB_BOLD);
+        }
+        if modifier.contains(Modifier::UNDERLINED) {
+            result.insert(rustbox::RB_UNDERLINE);
+        }
+        if modifier.contains(Modifier::REVERSED) {
+            result.insert(rustbox::RB_REVERSE);
+        }
+        result
+    }
+}
--- a/src/backend/termion.rs
+++ b/src/backend/termion.rs
@@ -1,36 +1,14 @@
-//! This module provides the `TermionBackend` implementation for the [`Backend`] trait.
-//! It uses the Termion crate to interact with the terminal.
-//!
-//! [`Backend`]: crate::backend::Backend
-//! [`TermionBackend`]: crate::backend::TermionBackend
-
+use super::Backend;
+use crate::{
+    buffer::Cell,
+    layout::Rect,
+    style::{Color, Modifier},
+};
 use std::{
    fmt,
    io::{self, Write},
 };

-use crate::{
-    backend::{Backend, ClearType},
-    buffer::Cell,
-    layout::Rect,
-    style::{Color, Modifier},
-};
-
-/// A backend that uses the Termion library to draw content, manipulate the cursor,
-/// and clear the terminal screen.
-///
-/// # Example
-///
-/// ```rust
-/// use ratatui::backend::{Backend, TermionBackend};
-///
-/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-/// let stdout = std::io::stdout();
-/// let mut backend = TermionBackend::new(stdout);
-/// backend.clear()?;
-/// # Ok(())
-/// # }
-/// ```
 pub struct TermionBackend<W>
 where
    W: Write,
@@ -42,7 +20,6 @@ impl<W> TermionBackend<W>
 where
    W: Write,
 {
-    /// Creates a new Termion backend with the given output.
    pub fn new(stdout: W) -> TermionBackend<W> {
        TermionBackend { stdout }
    }
@@ -65,42 +42,31 @@ impl<W> Backend for TermionBackend<W>
 where
    W: Write,
 {
+    /// Clears the entire screen and move the cursor to the top left of the screen
    fn clear(&mut self) -> io::Result<()> {
-        self.clear_region(ClearType::All)
-    }
-
-    fn clear_region(&mut self, clear_type: ClearType) -> io::Result<()> {
-        match clear_type {
-            ClearType::All => write!(self.stdout, "{}", termion::clear::All)?,
-            ClearType::AfterCursor => write!(self.stdout, "{}", termion::clear::AfterCursor)?,
-            ClearType::BeforeCursor => write!(self.stdout, "{}", termion::clear::BeforeCursor)?,
-            ClearType::CurrentLine => write!(self.stdout, "{}", termion::clear::CurrentLine)?,
-            ClearType::UntilNewLine => write!(self.stdout, "{}", termion::clear::UntilNewline)?,
-        };
-        self.stdout.flush()
-    }
-
-    fn append_lines(&mut self, n: u16) -> io::Result<()> {
-        for _ in 0..n {
-            writeln!(self.stdout)?;
-        }
+        write!(self.stdout, "{}", termion::clear::All)?;
+        write!(self.stdout, "{}", termion::cursor::Goto(1, 1))?;
        self.stdout.flush()
    }

+    /// Hides cursor
    fn hide_cursor(&mut self) -> io::Result<()> {
        write!(self.stdout, "{}", termion::cursor::Hide)?;
        self.stdout.flush()
    }

+    /// Shows cursor
    fn show_cursor(&mut self) -> io::Result<()> {
        write!(self.stdout, "{}", termion::cursor::Show)?;
        self.stdout.flush()
    }

+    /// Gets cursor position (0-based index)
    fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
        termion::cursor::DetectCursorPos::cursor_pos(&mut self.stdout).map(|(x, y)| (x - 1, y - 1))
    }

+    /// Sets cursor position (0-based index)
    fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
        write!(self.stdout, "{}", termion::cursor::Goto(x + 1, y + 1))?;
        self.stdout.flush()
@@ -147,13 +113,15 @@ where
        }
        write!(
            self.stdout,
-            "{string}{}{}{}",
+            "{}{}{}{}",
+            string,
            Fg(Color::Reset),
            Bg(Color::Reset),
            termion::style::Reset,
        )
    }

+    /// Return the size of the terminal
    fn size(&self) -> io::Result<Rect> {
        let terminal = termion::terminal_size()?;
        Ok(Rect::new(0, 0, terminal.0, terminal.1))
@@ -168,9 +136,6 @@ struct Fg(Color);

 struct Bg(Color);

-/// The `ModifierDiff` struct is used to calculate the difference between two `Modifier`
-/// values. This is useful when updating the terminal display, as it allows for more
-/// efficient updates by only sending the necessary changes.
 struct ModifierDiff {
    from: Modifier,
    to: Modifier,
--- a/src/backend/termwiz.rs
+++ b/src/backend/termwiz.rs
@@ -1,223 +0,0 @@
-//! This module provides the `TermwizBackend` implementation for the [`Backend`] trait.
-//! It uses the `termwiz` crate to interact with the terminal.
-//!
-//! [`Backend`]: trait.Backend.html
-//! [`TermwizBackend`]: crate::backend::TermionBackend
-
-use std::{error::Error, io};
-
-use termwiz::{
-    caps::Capabilities,
-    cell::{AttributeChange, Blink, Intensity, Underline},
-    color::{AnsiColor, ColorAttribute, SrgbaTuple},
-    surface::{Change, CursorVisibility, Position},
-    terminal::{buffered::BufferedTerminal, SystemTerminal, Terminal},
-};
-
-use crate::{
-    backend::Backend,
-    buffer::Cell,
-    layout::Rect,
-    style::{Color, Modifier},
-};
-
-/// Termwiz backend implementation for the [`Backend`] trait.
-/// # Example
-///
-/// ```rust
-/// use ratatui::backend::{Backend, TermwizBackend};
-///
-/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-/// let mut backend = TermwizBackend::new()?;
-/// backend.clear()?;
-/// # Ok(())
-/// # }
-/// ```
-pub struct TermwizBackend {
-    buffered_terminal: BufferedTerminal<SystemTerminal>,
-}
-
-impl TermwizBackend {
-    /// Creates a new Termwiz backend instance.
-    pub fn new() -> Result<TermwizBackend, Box<dyn Error>> {
-        let mut buffered_terminal =
-            BufferedTerminal::new(SystemTerminal::new(Capabilities::new_from_env()?)?)?;
-        buffered_terminal.terminal().set_raw_mode()?;
-        buffered_terminal.terminal().enter_alternate_screen()?;
-        Ok(TermwizBackend { buffered_terminal })
-    }
-
-    /// Creates a new Termwiz backend instance with the given buffered terminal.
-    pub fn with_buffered_terminal(instance: BufferedTerminal<SystemTerminal>) -> TermwizBackend {
-        TermwizBackend {
-            buffered_terminal: instance,
-        }
-    }
-
-    /// Returns a reference to the buffered terminal used by the backend.
-    pub fn buffered_terminal(&self) -> &BufferedTerminal<SystemTerminal> {
-        &self.buffered_terminal
-    }
-
-    /// Returns a mutable reference to the buffered terminal used by the backend.
-    pub fn buffered_terminal_mut(&mut self) -> &mut BufferedTerminal<SystemTerminal> {
-        &mut self.buffered_terminal
-    }
-}
-
-impl Backend for TermwizBackend {
-    fn draw<'a, I>(&mut self, content: I) -> Result<(), io::Error>
-    where
-        I: Iterator<Item = (u16, u16, &'a Cell)>,
-    {
-        for (x, y, cell) in content {
-            self.buffered_terminal.add_changes(vec![
-                Change::CursorPosition {
-                    x: Position::Absolute(x as usize),
-                    y: Position::Absolute(y as usize),
-                },
-                Change::Attribute(AttributeChange::Foreground(cell.fg.into())),
-                Change::Attribute(AttributeChange::Background(cell.bg.into())),
-            ]);
-
-            self.buffered_terminal
-                .add_change(Change::Attribute(AttributeChange::Intensity(
-                    if cell.modifier.contains(Modifier::BOLD) {
-                        Intensity::Bold
-                    } else if cell.modifier.contains(Modifier::DIM) {
-                        Intensity::Half
-                    } else {
-                        Intensity::Normal
-                    },
-                )));
-
-            self.buffered_terminal
-                .add_change(Change::Attribute(AttributeChange::Italic(
-                    cell.modifier.contains(Modifier::ITALIC),
-                )));
-
-            self.buffered_terminal
-                .add_change(Change::Attribute(AttributeChange::Underline(
-                    if cell.modifier.contains(Modifier::UNDERLINED) {
-                        Underline::Single
-                    } else {
-                        Underline::None
-                    },
-                )));
-
-            self.buffered_terminal
-                .add_change(Change::Attribute(AttributeChange::Reverse(
-                    cell.modifier.contains(Modifier::REVERSED),
-                )));
-
-            self.buffered_terminal
-                .add_change(Change::Attribute(AttributeChange::Invisible(
-                    cell.modifier.contains(Modifier::HIDDEN),
-                )));
-
-            self.buffered_terminal
-                .add_change(Change::Attribute(AttributeChange::StrikeThrough(
-                    cell.modifier.contains(Modifier::CROSSED_OUT),
-                )));
-
-            self.buffered_terminal
-                .add_change(Change::Attribute(AttributeChange::Blink(
-                    if cell.modifier.contains(Modifier::SLOW_BLINK) {
-                        Blink::Slow
-                    } else if cell.modifier.contains(Modifier::RAPID_BLINK) {
-                        Blink::Rapid
-                    } else {
-                        Blink::None
-                    },
-                )));
-
-            self.buffered_terminal.add_change(&cell.symbol);
-        }
-        Ok(())
-    }
-
-    fn hide_cursor(&mut self) -> Result<(), io::Error> {
-        self.buffered_terminal
-            .add_change(Change::CursorVisibility(CursorVisibility::Hidden));
-        Ok(())
-    }
-
-    fn show_cursor(&mut self) -> Result<(), io::Error> {
-        self.buffered_terminal
-            .add_change(Change::CursorVisibility(CursorVisibility::Visible));
-        Ok(())
-    }
-
-    fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
-        let (x, y) = self.buffered_terminal.cursor_position();
-        Ok((x as u16, y as u16))
-    }
-
-    fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
-        self.buffered_terminal.add_change(Change::CursorPosition {
-            x: Position::Absolute(x as usize),
-            y: Position::Absolute(y as usize),
-        });
-
-        Ok(())
-    }
-
-    fn clear(&mut self) -> Result<(), io::Error> {
-        self.buffered_terminal
-            .add_change(Change::ClearScreen(termwiz::color::ColorAttribute::Default));
-        Ok(())
-    }
-
-    fn size(&self) -> Result<Rect, io::Error> {
-        let (term_width, term_height) = self.buffered_terminal.dimensions();
-        let max = u16::max_value();
-        Ok(Rect::new(
-            0,
-            0,
-            if term_width > usize::from(max) {
-                max
-            } else {
-                term_width as u16
-            },
-            if term_height > usize::from(max) {
-                max
-            } else {
-                term_height as u16
-            },
-        ))
-    }
-
-    fn flush(&mut self) -> Result<(), io::Error> {
-        self.buffered_terminal
-            .flush()
-            .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
-        Ok(())
-    }
-}
-
-impl From<Color> for ColorAttribute {
-    fn from(color: Color) -> ColorAttribute {
-        match color {
-            Color::Reset => ColorAttribute::Default,
-            Color::Black => AnsiColor::Black.into(),
-            Color::Gray | Color::DarkGray => AnsiColor::Grey.into(),
-            Color::Red => AnsiColor::Maroon.into(),
-            Color::LightRed => AnsiColor::Red.into(),
-            Color::Green => AnsiColor::Green.into(),
-            Color::LightGreen => AnsiColor::Lime.into(),
-            Color::Yellow => AnsiColor::Olive.into(),
-            Color::LightYellow => AnsiColor::Yellow.into(),
-            Color::Magenta => AnsiColor::Purple.into(),
-            Color::LightMagenta => AnsiColor::Fuchsia.into(),
-            Color::Cyan => AnsiColor::Teal.into(),
-            Color::LightCyan => AnsiColor::Aqua.into(),
-            Color::White => AnsiColor::White.into(),
-            Color::Blue => AnsiColor::Navy.into(),
-            Color::LightBlue => AnsiColor::Blue.into(),
-            Color::Indexed(i) => ColorAttribute::PaletteIndex(i),
-            Color::Rgb(r, g, b) => {
-                ColorAttribute::TrueColorWithDefaultFallback(SrgbaTuple::from((r, g, b)))
-            }
-        }
-    }
-}
--- a/src/backend/test.rs
+++ b/src/backend/test.rs
@@ -1,33 +1,12 @@
-//! This module provides the `TestBackend` implementation for the [`Backend`] trait.
-//! It is used in the integration tests to verify the correctness of the library.
-
-use std::{
-    fmt::{Display, Write},
-    io,
-};
-
-use unicode_width::UnicodeWidthStr;
-
 use crate::{
    backend::Backend,
    buffer::{Buffer, Cell},
    layout::Rect,
 };
+use std::{fmt::Write, io};
+use unicode_width::UnicodeWidthStr;

 /// A backend used for the integration tests.
-///
-/// # Example
-///
-/// ```rust
-/// use ratatui::{backend::{Backend, TestBackend}, buffer::Buffer};
-///
-/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-/// let mut backend = TestBackend::new(10, 2);
-/// backend.clear()?;
-/// backend.assert_buffer(&Buffer::with_lines(vec!["          "; 2]));
-/// # Ok(())
-/// # }
-/// ```
 #[derive(Debug)]
 pub struct TestBackend {
    width: u16,
@@ -38,11 +17,6 @@ pub struct TestBackend {
 }

 /// Returns a string representation of the given buffer for debugging purpose.
-///
-/// This function is used to visualize the buffer content in a human-readable format.
-/// It iterates through the buffer content and appends each cell's symbol to the view string.
-/// If a cell is hidden by a multi-width symbol, it is added to the overwritten vector and
-/// displayed at the end of the line.
 fn buffer_view(buffer: &Buffer) -> String {
    let mut view = String::with_capacity(buffer.content.len() + buffer.area.height as usize * 3);
    for cells in buffer.content.chunks(buffer.area.width as usize) {
@@ -53,13 +27,18 @@ fn buffer_view(buffer: &Buffer) -> String {
            if skip == 0 {
                view.push_str(&c.symbol);
            } else {
-                overwritten.push((x, &c.symbol));
+                overwritten.push((x, &c.symbol))
            }
            skip = std::cmp::max(skip, c.symbol.width()).saturating_sub(1);
        }
        view.push('"');
        if !overwritten.is_empty() {
-            write!(&mut view, " Hidden by multi-width symbols: {overwritten:?}").unwrap();
+            write!(
+                &mut view,
+                " Hidden by multi-width symbols: {:?}",
+                overwritten
+            )
+            .unwrap();
        }
        view.push('\n');
    }
@@ -67,7 +46,6 @@ fn buffer_view(buffer: &Buffer) -> String {
 }

 impl TestBackend {
-    /// Creates a new TestBackend with the specified width and height.
    pub fn new(width: u16, height: u16) -> TestBackend {
        TestBackend {
            width,
@@ -78,21 +56,16 @@ impl TestBackend {
        }
    }

-    /// Returns a reference to the internal buffer of the TestBackend.
    pub fn buffer(&self) -> &Buffer {
        &self.buffer
    }

-    /// Resizes the TestBackend to the specified width and height.
    pub fn resize(&mut self, width: u16, height: u16) {
        self.buffer.resize(Rect::new(0, 0, width, height));
        self.width = width;
        self.height = height;
    }

-    /// Asserts that the TestBackend's buffer is equal to the expected buffer.
-    /// If the buffers are not equal, a panic occurs with a detailed error message
-    /// showing the differences between the expected and actual buffers.
    pub fn assert_buffer(&self, expected: &Buffer) {
        assert_eq!(expected.area, self.buffer.area);
        let diff = expected.diff(&self.buffer);
@@ -120,20 +93,15 @@ impl TestBackend {
            .enumerate()
            .map(|(i, (x, y, cell))| {
                let expected_cell = expected.get(*x, *y);
-                format!("{i}: at ({x}, {y}) expected {expected_cell:?} got {cell:?}")
+                format!(
+                    "{}: at ({}, {}) expected {:?} got {:?}",
+                    i, x, y, expected_cell, cell
+                )
            })
            .collect::<Vec<String>>()
            .join("\n");
        debug_info.push_str(&nice_diff);
-        panic!("{debug_info}");
-    }
-}
-
-impl Display for TestBackend {
-    /// Formats the TestBackend for display by calling the buffer_view function
-    /// on its internal buffer.
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", buffer_view(&self.buffer))
+        panic!("{}", debug_info);
    }
 }

--- a/src/buffer.rs
+++ b/src/buffer.rs
@@ -1,20 +1,14 @@
-use std::{
-    cmp::min,
-    fmt::{Debug, Formatter, Result},
-};
-
-use unicode_segmentation::UnicodeSegmentation;
-use unicode_width::UnicodeWidthStr;
-
-#[allow(deprecated)]
 use crate::{
    layout::Rect,
    style::{Color, Modifier, Style},
-    text::{Line, Span, Spans},
+    text::{Span, Spans},
 };
+use std::cmp::min;
+use unicode_segmentation::UnicodeSegmentation;
+use unicode_width::UnicodeWidthStr;

 /// A buffer cell
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Cell {
    pub symbol: String,
    pub fg: Color,
@@ -94,9 +88,9 @@ impl Default for Cell {
 /// # Examples:
 ///
 /// ```
-/// use ratatui::buffer::{Buffer, Cell};
-/// use ratatui::layout::Rect;
-/// use ratatui::style::{Color, Style, Modifier};
+/// use tui::buffer::{Buffer, Cell};
+/// use tui::layout::Rect;
+/// use tui::style::{Color, Style, Modifier};
 ///
 /// let mut buf = Buffer::empty(Rect{x: 0, y: 0, width: 10, height: 5});
 /// buf.get_mut(0, 2).set_symbol("x");
@@ -111,7 +105,7 @@ impl Default for Cell {
 /// buf.get_mut(5, 0).set_char('x');
 /// assert_eq!(buf.get(5, 0).symbol, "x");
 /// ```
-#[derive(Clone, PartialEq, Eq, Default)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Buffer {
    /// The area represented by this buffer
    pub area: Rect,
@@ -120,10 +114,19 @@ pub struct Buffer {
    pub content: Vec<Cell>,
 }

+impl Default for Buffer {
+    fn default() -> Buffer {
+        Buffer {
+            area: Default::default(),
+            content: Vec::new(),
+        }
+    }
+}
+
 impl Buffer {
    /// Returns a Buffer with all cells set to the default one
    pub fn empty(area: Rect) -> Buffer {
-        let cell = Cell::default();
+        let cell: Cell = Default::default();
        Buffer::filled(area, &cell)
    }

@@ -182,15 +185,15 @@ impl Buffer {
        &mut self.content[i]
    }

-    /// Returns the index in the `Vec<Cell>` for the given global (x, y) coordinates.
+    /// Returns the index in the Vec<Cell> for the given global (x, y) coordinates.
    ///
    /// Global coordinates are offset by the Buffer's area offset (`x`/`y`).
    ///
    /// # Examples
    ///
    /// ```
-    /// # use ratatui::buffer::Buffer;
-    /// # use ratatui::layout::Rect;
+    /// # use tui::buffer::Buffer;
+    /// # use tui::layout::Rect;
    /// let rect = Rect::new(200, 100, 10, 10);
    /// let buffer = Buffer::empty(rect);
    /// // Global coordinates to the top corner of this buffer's area
@@ -202,8 +205,8 @@ impl Buffer {
    /// Panics when given an coordinate that is outside of this Buffer's area.
    ///
    /// ```should_panic
-    /// # use ratatui::buffer::Buffer;
-    /// # use ratatui::layout::Rect;
+    /// # use tui::buffer::Buffer;
+    /// # use tui::layout::Rect;
    /// let rect = Rect::new(200, 100, 10, 10);
    /// let buffer = Buffer::empty(rect);
    /// // Top coordinate is outside of the buffer in global coordinate space, as the Buffer's area
@@ -216,7 +219,9 @@ impl Buffer {
                && x < self.area.right()
                && y >= self.area.top()
                && y < self.area.bottom(),
-            "Trying to access position outside the buffer: x={x}, y={y}, area={:?}",
+            "Trying to access position outside the buffer: x={}, y={}, area={:?}",
+            x,
+            y,
            self.area
        );
        ((y - self.area.y) * self.area.width + (x - self.area.x)) as usize
@@ -229,8 +234,8 @@ impl Buffer {
    /// # Examples
    ///
    /// ```
-    /// # use ratatui::buffer::Buffer;
-    /// # use ratatui::layout::Rect;
+    /// # use tui::buffer::Buffer;
+    /// # use tui::layout::Rect;
    /// let rect = Rect::new(200, 100, 10, 10);
    /// let buffer = Buffer::empty(rect);
    /// assert_eq!(buffer.pos_of(0), (200, 100));
@@ -242,8 +247,8 @@ impl Buffer {
    /// Panics when given an index that is outside the Buffer's content.
    ///
    /// ```should_panic
-    /// # use ratatui::buffer::Buffer;
-    /// # use ratatui::layout::Rect;
+    /// # use tui::buffer::Buffer;
+    /// # use tui::layout::Rect;
    /// let rect = Rect::new(0, 0, 10, 10); // 100 cells in total
    /// let buffer = Buffer::empty(rect);
    /// // Index 100 is the 101th cell, which lies outside of the area of this Buffer.
@@ -252,12 +257,13 @@ impl Buffer {
    pub fn pos_of(&self, i: usize) -> (u16, u16) {
        debug_assert!(
            i < self.content.len(),
-            "Trying to get the coords of a cell outside the buffer: i={i} len={}",
+            "Trying to get the coords of a cell outside the buffer: i={} len={}",
+            i,
            self.content.len()
        );
        (
-            self.area.x + (i as u16) % self.area.width,
-            self.area.y + (i as u16) / self.area.width,
+            self.area.x + i as u16 % self.area.width,
+            self.area.y + i as u16 / self.area.width,
        )
    }

@@ -292,7 +298,7 @@ impl Buffer {
                continue;
            }
            // `x_offset + width > max_offset` could be integer overflow on 32-bit machines if we
-            // change dimensions to usize or u32 and someone resizes the terminal to 1x2^32.
+            // change dimenstions to usize or u32 and someone resizes the terminal to 1x2^32.
            if width > max_offset.saturating_sub(x_offset) {
                break;
            }
@@ -309,9 +315,7 @@ impl Buffer {
        (x_offset as u16, y)
    }

-    #[allow(deprecated)]
-    #[deprecated(note = "Use `Buffer::set_line` instead")]
-    pub fn set_spans(&mut self, x: u16, y: u16, spans: &Spans<'_>, width: u16) -> (u16, u16) {
+    pub fn set_spans<'a>(&mut self, x: u16, y: u16, spans: &Spans<'a>, width: u16) -> (u16, u16) {
        let mut remaining_width = width;
        let mut x = x;
        for span in &spans.0 {
@@ -332,28 +336,7 @@ impl Buffer {
        (x, y)
    }

-    pub fn set_line(&mut self, x: u16, y: u16, line: &Line<'_>, width: u16) -> (u16, u16) {
-        let mut remaining_width = width;
-        let mut x = x;
-        for span in &line.spans {
-            if remaining_width == 0 {
-                break;
-            }
-            let pos = self.set_stringn(
-                x,
-                y,
-                span.content.as_ref(),
-                remaining_width as usize,
-                span.style,
-            );
-            let w = pos.0.saturating_sub(x);
-            x = pos.0;
-            remaining_width = remaining_width.saturating_sub(w);
-        }
-        (x, y)
-    }
-
-    pub fn set_span(&mut self, x: u16, y: u16, span: &Span<'_>, width: u16) -> (u16, u16) {
+    pub fn set_span<'a>(&mut self, x: u16, y: u16, span: &Span<'a>, width: u16) -> (u16, u16) {
        self.set_stringn(x, y, span.content.as_ref(), width as usize, span.style)
    }

@@ -384,7 +367,7 @@ impl Buffer {
        if self.content.len() > length {
            self.content.truncate(length);
        } else {
-            self.content.resize(length, Cell::default());
+            self.content.resize(length, Default::default());
        }
        self.area = area;
    }
@@ -399,7 +382,7 @@ impl Buffer {
    /// Merge an other buffer into this one
    pub fn merge(&mut self, other: &Buffer) {
        let area = self.area.union(other.area);
-        let cell = Cell::default();
+        let cell: Cell = Default::default();
        self.content.resize(area.area() as usize, cell.clone());

        // Move original content to the appropriate space
@@ -457,16 +440,18 @@ impl Buffer {
    pub fn diff<'a>(&self, other: &'a Buffer) -> Vec<(u16, u16, &'a Cell)> {
        let previous_buffer = &self.content;
        let next_buffer = &other.content;
+        let width = self.area.width;

        let mut updates: Vec<(u16, u16, &Cell)> = vec![];
-        // Cells invalidated by drawing/replacing preceding multi-width characters:
+        // Cells invalidated by drawing/replacing preceeding multi-width characters:
        let mut invalidated: usize = 0;
-        // Cells from the current buffer to skip due to preceding multi-width characters taking
-        // their place (the skipped cells should be blank anyway):
+        // Cells from the current buffer to skip due to preceeding multi-width characters taking their
+        // place (the skipped cells should be blank anyway):
        let mut to_skip: usize = 0;
        for (i, (current, previous)) in next_buffer.iter().zip(previous_buffer.iter()).enumerate() {
            if (current != previous || invalidated > 0) && to_skip == 0 {
-                let (x, y) = self.pos_of(i);
+                let x = i as u16 % width;
+                let y = i as u16 / width;
                updates.push((x, y, &next_buffer[i]));
            }

@@ -479,111 +464,6 @@ impl Buffer {
    }
 }

-/// Assert that two buffers are equal by comparing their areas and content.
-///
-/// On panic, displays the areas or the content and a diff of the contents.
-#[macro_export]
-macro_rules! assert_buffer_eq {
-    ($actual_expr:expr, $expected_expr:expr) => {
-        match (&$actual_expr, &$expected_expr) {
-            (actual, expected) => {
-                if actual.area != expected.area {
-                    panic!(
-                        indoc::indoc!(
-                            "
-                            buffer areas not equal
-                            expected:  {:?}
-                            actual:    {:?}"
-                        ),
-                        expected, actual
-                    );
-                }
-                let diff = expected.diff(&actual);
-                if !diff.is_empty() {
-                    let nice_diff = diff
-                        .iter()
-                        .enumerate()
-                        .map(|(i, (x, y, cell))| {
-                            let expected_cell = expected.get(*x, *y);
-                            indoc::formatdoc! {"
-                                {i}: at ({x}, {y})
-                                  expected: {expected_cell:?}
-                                  actual:   {cell:?}
-                            "}
-                        })
-                        .collect::<Vec<String>>()
-                        .join("\n");
-                    panic!(
-                        indoc::indoc!(
-                            "
-                            buffer contents not equal
-                            expected: {:?}
-                            actual: {:?}
-                            diff:
-                            {}"
-                        ),
-                        expected, actual, nice_diff
-                    );
-                }
-                // shouldn't get here, but this guards against future behavior
-                // that changes equality but not area or content
-                assert_eq!(actual, expected, "buffers not equal");
-            }
-        }
-    };
-}
-
-impl Debug for Buffer {
-    /// Writes a debug representation of the buffer to the given formatter.
-    ///
-    /// The format is like a pretty printed struct, with the following fields:
-    /// * `area`: displayed as `Rect { x: 1, y: 2, width: 3, height: 4 }`
-    /// * `content`: displayed as a list of strings representing the content of the buffer
-    /// * `styles`: displayed as a list of: `{ x: 1, y: 2, fg: Color::Red, bg: Color::Blue,
-    ///   modifier: Modifier::BOLD }` only showing a value when there is a change in style.
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        f.write_fmt(format_args!(
-            "Buffer {{\n    area: {:?},\n    content: [\n",
-            &self.area
-        ))?;
-        let mut last_style = None;
-        let mut styles = vec![];
-        for (y, line) in self.content.chunks(self.area.width as usize).enumerate() {
-            let mut overwritten = vec![];
-            let mut skip: usize = 0;
-            f.write_str("        \"")?;
-            for (x, c) in line.iter().enumerate() {
-                if skip == 0 {
-                    f.write_str(&c.symbol)?;
-                } else {
-                    overwritten.push((x, &c.symbol));
-                }
-                skip = std::cmp::max(skip, c.symbol.width()).saturating_sub(1);
-                let style = (c.fg, c.bg, c.modifier);
-                if last_style != Some(style) {
-                    last_style = Some(style);
-                    styles.push((x, y, c.fg, c.bg, c.modifier));
-                }
-            }
-            if !overwritten.is_empty() {
-                f.write_fmt(format_args!(
-                    "// hidden by multi-width symbols: {overwritten:?}"
-                ))?;
-            }
-            f.write_str("\",\n")?;
-        }
-        f.write_str("    ],\n    styles: [\n")?;
-        for s in styles {
-            f.write_fmt(format_args!(
-                "        x: {}, y: {}, fg: {:?}, bg: {:?}, modifier: {:?},\n",
-                s.0, s.1, s.2, s.3, s.4
-            ))?;
-        }
-        f.write_str("    ]\n}")?;
-        Ok(())
-    }
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -594,62 +474,6 @@ mod tests {
        cell
    }

-    #[test]
-    fn it_implements_debug() {
-        let mut buf = Buffer::empty(Rect::new(0, 0, 12, 2));
-        buf.set_string(0, 0, "Hello World!", Style::default());
-        buf.set_string(
-            0,
-            1,
-            "G'day World!",
-            Style::default()
-                .fg(Color::Green)
-                .bg(Color::Yellow)
-                .add_modifier(Modifier::BOLD),
-        );
-        assert_eq!(
-            format!("{buf:?}"),
-            indoc::indoc!(
-                "
-                Buffer {
-                    area: Rect { x: 0, y: 0, width: 12, height: 2 },
-                    content: [
-                        \"Hello World!\",
-                        \"G'day World!\",
-                    ],
-                    styles: [
-                        x: 0, y: 0, fg: Reset, bg: Reset, modifier: NONE,
-                        x: 0, y: 1, fg: Green, bg: Yellow, modifier: BOLD,
-                    ]
-                }"
-            )
-        );
-    }
-
-    #[test]
-    fn assert_buffer_eq_does_not_panic_on_equal_buffers() {
-        let buffer = Buffer::empty(Rect::new(0, 0, 5, 1));
-        let other_buffer = Buffer::empty(Rect::new(0, 0, 5, 1));
-        assert_buffer_eq!(buffer, other_buffer);
-    }
-
-    #[should_panic]
-    #[test]
-    fn assert_buffer_eq_panics_on_unequal_area() {
-        let buffer = Buffer::empty(Rect::new(0, 0, 5, 1));
-        let other_buffer = Buffer::empty(Rect::new(0, 0, 6, 1));
-        assert_buffer_eq!(buffer, other_buffer);
-    }
-
-    #[should_panic]
-    #[test]
-    fn assert_buffer_eq_panics_on_unequal_style() {
-        let buffer = Buffer::empty(Rect::new(0, 0, 5, 1));
-        let mut other_buffer = Buffer::empty(Rect::new(0, 0, 5, 1));
-        other_buffer.set_string(0, 0, " ", Style::default().fg(Color::Red));
-        assert_buffer_eq!(buffer, other_buffer);
-    }
-
    #[test]
    fn it_translates_to_and_from_coordinates() {
        let rect = Rect::new(200, 100, 50, 80);
@@ -691,38 +515,21 @@ mod tests {

        // Zero-width
        buffer.set_stringn(0, 0, "aaa", 0, Style::default());
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["     "]));
+        assert_eq!(buffer, Buffer::with_lines(vec!["     "]));

        buffer.set_string(0, 0, "aaa", Style::default());
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["aaa  "]));
+        assert_eq!(buffer, Buffer::with_lines(vec!["aaa  "]));

        // Width limit:
        buffer.set_stringn(0, 0, "bbbbbbbbbbbbbb", 4, Style::default());
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["bbbb "]));
+        assert_eq!(buffer, Buffer::with_lines(vec!["bbbb "]));

        buffer.set_string(0, 0, "12345", Style::default());
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["12345"]));
+        assert_eq!(buffer, Buffer::with_lines(vec!["12345"]));

        // Width truncation:
        buffer.set_string(0, 0, "123456", Style::default());
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["12345"]));
-
-        // multi-line
-        buffer = Buffer::empty(Rect::new(0, 0, 5, 2));
-        buffer.set_string(0, 0, "12345", Style::default());
-        buffer.set_string(0, 1, "67890", Style::default());
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["12345", "67890"]));
-    }
-
-    #[test]
-    fn buffer_set_string_multi_width_overwrite() {
-        let area = Rect::new(0, 0, 5, 1);
-        let mut buffer = Buffer::empty(area);
-
-        // multi-width overwrite
-        buffer.set_string(0, 0, "aaaaa", Style::default());
-        buffer.set_string(0, 0, "称号", Style::default());
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["称号a"]));
+        assert_eq!(buffer, Buffer::with_lines(vec!["12345"]));
    }

    #[test]
@@ -733,12 +540,12 @@ mod tests {
        // Leading grapheme with zero width
        let s = "\u{1}a";
        buffer.set_stringn(0, 0, s, 1, Style::default());
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["a"]));
+        assert_eq!(buffer, Buffer::with_lines(vec!["a"]));

        // Trailing grapheme with zero with
        let s = "a\u{1}";
        buffer.set_stringn(0, 0, s, 1, Style::default());
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["a"]));
+        assert_eq!(buffer, Buffer::with_lines(vec!["a"]));
    }

    #[test]
@@ -746,11 +553,11 @@ mod tests {
        let area = Rect::new(0, 0, 5, 1);
        let mut buffer = Buffer::empty(area);
        buffer.set_string(0, 0, "コン", Style::default());
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["コン "]));
+        assert_eq!(buffer, Buffer::with_lines(vec!["コン "]));

        // Only 1 space left.
        buffer.set_string(0, 0, "コンピ", Style::default());
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["コン "]));
+        assert_eq!(buffer, Buffer::with_lines(vec!["コン "]));
    }

    #[test]
@@ -875,7 +682,7 @@ mod tests {
            Cell::default().set_symbol("2"),
        );
        one.merge(&two);
-        assert_buffer_eq!(one, Buffer::with_lines(vec!["11", "11", "22", "22"]));
+        assert_eq!(one, Buffer::with_lines(vec!["11", "11", "22", "22"]));
    }

    #[test]
@@ -899,7 +706,7 @@ mod tests {
            Cell::default().set_symbol("2"),
        );
        one.merge(&two);
-        assert_buffer_eq!(
+        assert_eq!(
            one,
            Buffer::with_lines(vec!["22  ", "22  ", "  11", "  11"])
        );
@@ -933,6 +740,6 @@ mod tests {
            width: 4,
            height: 4,
        };
-        assert_buffer_eq!(one, merged);
+        assert_eq!(one, merged);
    }
 }
--- a/src/layout.rs
+++ b/src/layout.rs
@@ -1,15 +1,10 @@
-use std::{
-    cell::RefCell,
-    cmp::{max, min},
-    collections::HashMap,
-    rc::Rc,
-};
+use std::cell::RefCell;
+use std::cmp::{max, min};
+use std::collections::HashMap;

-use cassowary::{
-    strength::{MEDIUM, REQUIRED, WEAK},
-    Constraint as CassowaryConstraint, Expression, Solver, Variable,
-    WeightedRelation::{EQ, GE, LE},
-};
+use cassowary::strength::{REQUIRED, WEAK};
+use cassowary::WeightedRelation::*;
+use cassowary::{Constraint as CassowaryConstraint, Expression, Solver, Variable};

 #[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)]
 pub enum Corner {
@@ -27,6 +22,7 @@ pub enum Direction {

 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum Constraint {
+    // TODO: enforce range 0 - 100
    Percentage(u16),
    Ratio(u32, u32),
    Length(u16),
@@ -37,17 +33,10 @@ pub enum Constraint {
 impl Constraint {
    pub fn apply(&self, length: u16) -> u16 {
        match *self {
-            Constraint::Percentage(p) => {
-                let p = p as f32 / 100.0;
-                let length = length as f32;
-                (p * length).min(length) as u16
-            }
-            Constraint::Ratio(numerator, denominator) => {
-                // avoid division by zero by using 1 when denominator is 0
-                // this results in 0/0 -> 0 and x/0 -> x for x != 0
-                let percentage = numerator as f32 / denominator.max(1) as f32;
-                let length = length as f32;
-                (percentage * length).min(length) as u16
+            Constraint::Percentage(p) => length * p / 100,
+            Constraint::Ratio(num, den) => {
+                let r = num * u32::from(length) / den;
+                r as u16
            }
            Constraint::Length(l) => length.min(l),
            Constraint::Max(m) => length.min(m),
@@ -62,7 +51,7 @@ pub struct Margin {
    pub horizontal: u16,
 }

-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Alignment {
    Left,
    Center,
@@ -79,19 +68,12 @@ pub struct Layout {
    expand_to_fill: bool,
 }

-type Cache = HashMap<(Rect, Layout), Rc<[Rect]>>;
 thread_local! {
-    static LAYOUT_CACHE: RefCell<Cache> = RefCell::new(HashMap::new());
+    static LAYOUT_CACHE: RefCell<HashMap<(Rect, Layout), Vec<Rect>>> = RefCell::new(HashMap::new());
 }

 impl Default for Layout {
    fn default() -> Layout {
-        Layout::new()
-    }
-}
-
-impl Layout {
-    pub const fn new() -> Layout {
        Layout {
            direction: Direction::Vertical,
            margin: Margin {
@@ -102,7 +84,9 @@ impl Layout {
            expand_to_fill: true,
        }
    }
+}

+impl Layout {
    pub fn constraints<C>(mut self, constraints: C) -> Layout
    where
        C: Into<Vec<Constraint>>,
@@ -111,7 +95,7 @@ impl Layout {
        self
    }

-    pub const fn margin(mut self, margin: u16) -> Layout {
+    pub fn margin(mut self, margin: u16) -> Layout {
        self.margin = Margin {
            horizontal: margin,
            vertical: margin,
@@ -119,22 +103,22 @@ impl Layout {
        self
    }

-    pub const fn horizontal_margin(mut self, horizontal: u16) -> Layout {
+    pub fn horizontal_margin(mut self, horizontal: u16) -> Layout {
        self.margin.horizontal = horizontal;
        self
    }

-    pub const fn vertical_margin(mut self, vertical: u16) -> Layout {
+    pub fn vertical_margin(mut self, vertical: u16) -> Layout {
        self.margin.vertical = vertical;
        self
    }

-    pub const fn direction(mut self, direction: Direction) -> Layout {
+    pub fn direction(mut self, direction: Direction) -> Layout {
        self.direction = direction;
        self
    }

-    pub(crate) const fn expand_to_fill(mut self, expand_to_fill: bool) -> Layout {
+    pub(crate) fn expand_to_fill(mut self, expand_to_fill: bool) -> Layout {
        self.expand_to_fill = expand_to_fill;
        self
    }
@@ -144,7 +128,7 @@ impl Layout {
    ///
    /// # Examples
    /// ```
-    /// # use ratatui::layout::{Rect, Constraint, Direction, Layout};
+    /// # use tui::layout::{Rect, Constraint, Direction, Layout};
    /// let chunks = Layout::default()
    ///     .direction(Direction::Vertical)
    ///     .constraints([Constraint::Length(5), Constraint::Min(0)].as_ref())
@@ -155,8 +139,8 @@ impl Layout {
    ///         height: 10,
    ///     });
    /// assert_eq!(
-    ///     chunks[..],
-    ///     [
+    ///     chunks,
+    ///     vec![
    ///         Rect {
    ///             x: 2,
    ///             y: 2,
@@ -182,8 +166,8 @@ impl Layout {
    ///         height: 2,
    ///     });
    /// assert_eq!(
-    ///     chunks[..],
-    ///     [
+    ///     chunks,
+    ///     vec![
    ///         Rect {
    ///             x: 0,
    ///             y: 0,
@@ -199,7 +183,7 @@ impl Layout {
    ///     ]
    /// );
    /// ```
-    pub fn split(&self, area: Rect) -> Rc<[Rect]> {
+    pub fn split(&self, area: Rect) -> Vec<Rect> {
        // TODO: Maybe use a fixed size cache ?
        LAYOUT_CACHE.with(|c| {
            c.borrow_mut()
@@ -210,7 +194,7 @@ impl Layout {
    }
 }

-fn split(area: Rect, layout: &Layout) -> Rc<[Rect]> {
+fn split(area: Rect, layout: &Layout) -> Vec<Rect> {
    let mut solver = Solver::new();
    let mut vars: HashMap<Variable, (usize, usize)> = HashMap::new();
    let elements = layout
@@ -218,13 +202,11 @@ fn split(area: Rect, layout: &Layout) -> Rc<[Rect]> {
        .iter()
        .map(|_| Element::new())
        .collect::<Vec<Element>>();
-    let mut res = layout
+    let mut results = layout
        .constraints
        .iter()
        .map(|_| Rect::default())
-        .collect::<Rc<[Rect]>>();
-
-    let results = Rc::get_mut(&mut res).expect("newly created Rc should have no shared refs");
+        .collect::<Vec<Rect>>();

    let dest_area = area.inner(&layout.margin);
    for (i, e) in elements.iter().enumerate() {
@@ -266,25 +248,18 @@ fn split(area: Rect, layout: &Layout) -> Rc<[Rect]> {
                ccs.push(elements[i].y | EQ(REQUIRED) | f64::from(dest_area.y));
                ccs.push(elements[i].height | EQ(REQUIRED) | f64::from(dest_area.height));
                ccs.push(match *size {
-                    Constraint::Length(v) => elements[i].width | EQ(MEDIUM) | f64::from(v),
+                    Constraint::Length(v) => elements[i].width | EQ(WEAK) | f64::from(v),
                    Constraint::Percentage(v) => {
-                        elements[i].width | EQ(MEDIUM) | (f64::from(v * dest_area.width) / 100.0)
+                        elements[i].width | EQ(WEAK) | (f64::from(v * dest_area.width) / 100.0)
                    }
                    Constraint::Ratio(n, d) => {
                        elements[i].width
-                            | EQ(MEDIUM)
+                            | EQ(WEAK)
                            | (f64::from(dest_area.width) * f64::from(n) / f64::from(d))
                    }
-                    Constraint::Min(v) => elements[i].width | GE(MEDIUM) | f64::from(v),
-                    Constraint::Max(v) => elements[i].width | LE(MEDIUM) | f64::from(v),
+                    Constraint::Min(v) => elements[i].width | GE(WEAK) | f64::from(v),
+                    Constraint::Max(v) => elements[i].width | LE(WEAK) | f64::from(v),
                });
-
-                match *size {
-                    Constraint::Min(v) | Constraint::Max(v) => {
-                        ccs.push(elements[i].width | EQ(WEAK) | f64::from(v));
-                    }
-                    _ => {}
-                }
            }
        }
        Direction::Vertical => {
@@ -295,25 +270,18 @@ fn split(area: Rect, layout: &Layout) -> Rc<[Rect]> {
                ccs.push(elements[i].x | EQ(REQUIRED) | f64::from(dest_area.x));
                ccs.push(elements[i].width | EQ(REQUIRED) | f64::from(dest_area.width));
                ccs.push(match *size {
-                    Constraint::Length(v) => elements[i].height | EQ(MEDIUM) | f64::from(v),
+                    Constraint::Length(v) => elements[i].height | EQ(WEAK) | f64::from(v),
                    Constraint::Percentage(v) => {
-                        elements[i].height | EQ(MEDIUM) | (f64::from(v * dest_area.height) / 100.0)
+                        elements[i].height | EQ(WEAK) | (f64::from(v * dest_area.height) / 100.0)
                    }
                    Constraint::Ratio(n, d) => {
                        elements[i].height
-                            | EQ(MEDIUM)
+                            | EQ(WEAK)
                            | (f64::from(dest_area.height) * f64::from(n) / f64::from(d))
                    }
-                    Constraint::Min(v) => elements[i].height | GE(MEDIUM) | f64::from(v),
-                    Constraint::Max(v) => elements[i].height | LE(MEDIUM) | f64::from(v),
+                    Constraint::Min(v) => elements[i].height | GE(WEAK) | f64::from(v),
+                    Constraint::Max(v) => elements[i].height | LE(WEAK) | f64::from(v),
                });
-
-                match *size {
-                    Constraint::Min(v) | Constraint::Max(v) => {
-                        ccs.push(elements[i].height | EQ(WEAK) | f64::from(v));
-                    }
-                    _ => {}
-                }
            }
        }
    }
@@ -355,7 +323,7 @@ fn split(area: Rect, layout: &Layout) -> Rc<[Rect]> {
            }
        }
    }
-    res
+    results
 }

 /// A container used by the solver inside split
@@ -393,9 +361,9 @@ impl Element {
    }
 }

-/// A simple rectangle used in the computation of the layout and to give widgets a hint about the
+/// A simple rectangle used in the computation of the layout and to give widgets an hint about the
 /// area they are supposed to render to.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Default)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
 pub struct Rect {
    pub x: u16,
    pub y: u16,
@@ -403,6 +371,17 @@ pub struct Rect {
    pub height: u16,
 }

+impl Default for Rect {
+    fn default() -> Rect {
+        Rect {
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+        }
+    }
+}
+
 impl Rect {
    /// Creates a new rect, with width and height limited to keep the area under max u16.
    /// If clipped, aspect ratio will be preserved.
@@ -426,23 +405,23 @@ impl Rect {
        }
    }

-    pub const fn area(self) -> u16 {
+    pub fn area(self) -> u16 {
        self.width * self.height
    }

-    pub const fn left(self) -> u16 {
+    pub fn left(self) -> u16 {
        self.x
    }

-    pub const fn right(self) -> u16 {
+    pub fn right(self) -> u16 {
        self.x.saturating_add(self.width)
    }

-    pub const fn top(self) -> u16 {
+    pub fn top(self) -> u16 {
        self.y
    }

-    pub const fn bottom(self) -> u16 {
+    pub fn bottom(self) -> u16 {
        self.y.saturating_add(self.height)
    }

@@ -485,7 +464,7 @@ impl Rect {
        }
    }

-    pub const fn intersects(self, other: Rect) -> bool {
+    pub fn intersects(self, other: Rect) -> bool {
        self.x < other.x + other.width
            && self.x + self.width > other.x
            && self.y < other.y + other.height
@@ -536,7 +515,7 @@ mod tests {
                        - f64::from(width) / f64::from(height))
                    .abs()
                        < 1.0
-                );
+                )
            }
        }

@@ -565,68 +544,4 @@ mod tests {
        assert_eq!(rect.width, 300);
        assert_eq!(rect.height, 100);
    }
-
-    #[test]
-    fn test_constraint_apply() {
-        assert_eq!(Constraint::Percentage(0).apply(100), 0);
-        assert_eq!(Constraint::Percentage(50).apply(100), 50);
-        assert_eq!(Constraint::Percentage(100).apply(100), 100);
-        assert_eq!(Constraint::Percentage(200).apply(100), 100);
-        assert_eq!(Constraint::Percentage(u16::MAX).apply(100), 100);
-
-        // 0/0 intentionally avoids a panic by returning 0.
-        assert_eq!(Constraint::Ratio(0, 0).apply(100), 0);
-        // 1/0 intentionally avoids a panic by returning 100% of the length.
-        assert_eq!(Constraint::Ratio(1, 0).apply(100), 100);
-        assert_eq!(Constraint::Ratio(0, 1).apply(100), 0);
-        assert_eq!(Constraint::Ratio(1, 2).apply(100), 50);
-        assert_eq!(Constraint::Ratio(2, 2).apply(100), 100);
-        assert_eq!(Constraint::Ratio(3, 2).apply(100), 100);
-        assert_eq!(Constraint::Ratio(u32::MAX, 2).apply(100), 100);
-
-        assert_eq!(Constraint::Length(0).apply(100), 0);
-        assert_eq!(Constraint::Length(50).apply(100), 50);
-        assert_eq!(Constraint::Length(100).apply(100), 100);
-        assert_eq!(Constraint::Length(200).apply(100), 100);
-        assert_eq!(Constraint::Length(u16::MAX).apply(100), 100);
-
-        assert_eq!(Constraint::Max(0).apply(100), 0);
-        assert_eq!(Constraint::Max(50).apply(100), 50);
-        assert_eq!(Constraint::Max(100).apply(100), 100);
-        assert_eq!(Constraint::Max(200).apply(100), 100);
-        assert_eq!(Constraint::Max(u16::MAX).apply(100), 100);
-
-        assert_eq!(Constraint::Min(0).apply(100), 100);
-        assert_eq!(Constraint::Min(50).apply(100), 100);
-        assert_eq!(Constraint::Min(100).apply(100), 100);
-        assert_eq!(Constraint::Min(200).apply(100), 200);
-        assert_eq!(Constraint::Min(u16::MAX).apply(100), u16::MAX);
-    }
-
-    #[test]
-    fn rect_can_be_const() {
-        const RECT: Rect = Rect {
-            x: 0,
-            y: 0,
-            width: 10,
-            height: 10,
-        };
-        const _AREA: u16 = RECT.area();
-        const _LEFT: u16 = RECT.left();
-        const _RIGHT: u16 = RECT.right();
-        const _TOP: u16 = RECT.top();
-        const _BOTTOM: u16 = RECT.bottom();
-        assert!(RECT.intersects(RECT));
-    }
-
-    #[test]
-    fn layout_can_be_const() {
-        const _LAYOUT: Layout = Layout::new();
-        const _DEFAULT_LAYOUT: Layout = Layout::new()
-            .direction(Direction::Horizontal)
-            .margin(1)
-            .expand_to_fill(false);
-        const _HORIZONTAL_LAYOUT: Layout = Layout::new().horizontal_margin(1);
-        const _VERTICAL_LAYOUT: Layout = Layout::new().vertical_margin(1);
-    }
 }
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,63 +1,40 @@
-//! [ratatui](https://github.com/tui-rs-revival/ratatui) is a library used to build rich
+//! [tui](https://github.com/fdehau/tui-rs) is a library used to build rich
 //! terminal users interfaces and dashboards.
 //!
-//! ![](https://raw.githubusercontent.com/tui-rs-revival/ratatui/master/assets/demo.gif)
+//! ![](https://raw.githubusercontent.com/fdehau/tui-rs/master/assets/demo.gif)
 //!
 //! # Get started
 //!
-//! ## Adding `ratatui` as a dependency
+//! ## Adding `tui` as a dependency
 //!
-//! Add the following to your `Cargo.toml`:
 //! ```toml
 //! [dependencies]
-//! crossterm = "0.26"
-//! ratatui = "0.20"
+//! tui = "0.16"
+//! termion = "1.5"
 //! ```
 //!
-//! The crate is using the `crossterm` backend by default that works on most platforms. But if for
-//! example you want to use the `termion` backend instead. This can be done by changing your
-//! dependencies specification to the following:
+//! The crate is using the `termion` backend by default but if for example you want your
+//! application to work on Windows, you might want to use the `crossterm` backend instead. This can
+//! be done by changing your dependencies specification to the following:
 //!
 //! ```toml
 //! [dependencies]
-//! termion = "1.5"
-//! ratatui = { version = "0.20", default-features = false, features = ['termion'] }
+//! crossterm = "0.20"
+//! tui = { version = "0.16", default-features = false, features = ['crossterm'] }
 //! ```
 //!
 //! The same logic applies for all other available backends.
 //!
-//! ### Features
-//!
-//! Widgets which add dependencies are gated behind feature flags to prevent unused transitive
-//! dependencies. The available features are:
-//!
-//! * `widget-calendar` - enables [`widgets::calendar`] and adds a dependency on the [time
-//! crate](https://crates.io/crates/time).
-//!
 //! ## Creating a `Terminal`
 //!
-//! Every application using `ratatui` should start by instantiating a `Terminal`. It is a light
+//! Every application using `tui` should start by instantiating a `Terminal`. It is a light
 //! abstraction over available backends that provides basic functionalities such as clearing the
 //! screen, hiding the cursor, etc.
 //!
 //! ```rust,no_run
 //! use std::io;
-//! use ratatui::{backend::CrosstermBackend, Terminal};
-//!
-//! fn main() -> Result<(), io::Error> {
-//!     let stdout = io::stdout();
-//!     let backend = CrosstermBackend::new(stdout);
-//!     let mut terminal = Terminal::new(backend)?;
-//!     Ok(())
-//! }
-//! ```
-//!
-//! If you had previously chosen `termion` as a backend, the terminal can be created in a similar
-//! way:
-//!
-//! ```rust,ignore
-//! use std::io;
-//! use ratatui::{backend::TermionBackend, Terminal};
+//! use tui::Terminal;
+//! use tui::backend::TermionBackend;
 //! use termion::raw::IntoRawMode;
 //!
 //! fn main() -> Result<(), io::Error> {
@@ -68,6 +45,22 @@
 //! }
 //! ```
 //!
+//! If you had previously chosen `crossterm` as a backend, the terminal can be created in a similar
+//! way:
+//!
+//! ```rust,ignore
+//! use std::io;
+//! use tui::Terminal;
+//! use tui::backend::CrosstermBackend;
+//!
+//! fn main() -> Result<(), io::Error> {
+//!     let stdout = io::stdout();
+//!     let backend = CrosstermBackend::new(stdout);
+//!     let mut terminal = Terminal::new(backend)?;
+//!     Ok(())
+//! }
+//! ```
+//!
 //! You may also refer to the examples to find out how to create a `Terminal` for each available
 //! backend.
 //!
@@ -84,26 +77,17 @@
 //! The following example renders a block of the size of the terminal:
 //!
 //! ```rust,no_run
-//! use std::{io, thread, time::Duration};
-//! use ratatui::{
-//!     backend::CrosstermBackend,
-//!     widgets::{Block, Borders},
-//!     Terminal
-//! };
-//! use crossterm::{
-//!     event::{self, DisableMouseCapture, EnableMouseCapture},
-//!     execute,
-//!     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
-//! };
+//! use std::io;
+//! use termion::raw::IntoRawMode;
+//! use tui::Terminal;
+//! use tui::backend::TermionBackend;
+//! use tui::widgets::{Widget, Block, Borders};
+//! use tui::layout::{Layout, Constraint, Direction};
 //!
 //! fn main() -> Result<(), io::Error> {
-//!     // setup terminal
-//!     enable_raw_mode()?;
-//!     let mut stdout = io::stdout();
-//!     execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
-//!     let backend = CrosstermBackend::new(stdout);
+//!     let stdout = io::stdout().into_raw_mode()?;
+//!     let backend = TermionBackend::new(stdout);
 //!     let mut terminal = Terminal::new(backend)?;
-//!
 //!     terminal.draw(|f| {
 //!         let size = f.size();
 //!         let block = Block::default()
@@ -111,24 +95,6 @@
 //!             .borders(Borders::ALL);
 //!         f.render_widget(block, size);
 //!     })?;
-//!
-//!     // Start a thread to discard any input events. Without handling events, the
-//!     // stdin buffer will fill up, and be read into the shell when the program exits.
-//!     thread::spawn(|| loop {
-//!         event::read();
-//!     });
-//!
-//!     thread::sleep(Duration::from_millis(5000));
-//!
-//!     // restore terminal
-//!     disable_raw_mode()?;
-//!     execute!(
-//!         terminal.backend_mut(),
-//!         LeaveAlternateScreen,
-//!         DisableMouseCapture
-//!     )?;
-//!     terminal.show_cursor()?;
-//!
 //!     Ok(())
 //! }
 //! ```
@@ -140,32 +106,39 @@
 //! full customization. And `Layout` is no exception:
 //!
 //! ```rust,no_run
-//! use ratatui::{
-//!     backend::Backend,
-//!     layout::{Constraint, Direction, Layout},
-//!     widgets::{Block, Borders},
-//!     Frame,
-//! };
-//! fn ui<B: Backend>(f: &mut Frame<B>) {
-//!    let chunks = Layout::default()
-//!         .direction(Direction::Vertical)
-//!         .margin(1)
-//!         .constraints(
-//!             [
-//!                 Constraint::Percentage(10),
-//!                 Constraint::Percentage(80),
-//!                 Constraint::Percentage(10)
-//!             ].as_ref()
-//!         )
-//!         .split(f.size());
-//!     let block = Block::default()
-//!          .title("Block")
-//!          .borders(Borders::ALL);
-//!     f.render_widget(block, chunks[0]);
-//!     let block = Block::default()
-//!          .title("Block 2")
-//!          .borders(Borders::ALL);
-//!     f.render_widget(block, chunks[1]);
+//! use std::io;
+//! use termion::raw::IntoRawMode;
+//! use tui::Terminal;
+//! use tui::backend::TermionBackend;
+//! use tui::widgets::{Widget, Block, Borders};
+//! use tui::layout::{Layout, Constraint, Direction};
+//!
+//! fn main() -> Result<(), io::Error> {
+//!     let stdout = io::stdout().into_raw_mode()?;
+//!     let backend = TermionBackend::new(stdout);
+//!     let mut terminal = Terminal::new(backend)?;
+//!     terminal.draw(|f| {
+//!         let chunks = Layout::default()
+//!             .direction(Direction::Vertical)
+//!             .margin(1)
+//!             .constraints(
+//!                 [
+//!                     Constraint::Percentage(10),
+//!                     Constraint::Percentage(80),
+//!                     Constraint::Percentage(10)
+//!                 ].as_ref()
+//!             )
+//!             .split(f.size());
+//!         let block = Block::default()
+//!              .title("Block")
+//!              .borders(Borders::ALL);
+//!         f.render_widget(block, chunks[0]);
+//!         let block = Block::default()
+//!              .title("Block 2")
+//!              .borders(Borders::ALL);
+//!         f.render_widget(block, chunks[1]);
+//!     })?;
+//!     Ok(())
 //! }
 //! ```
 //!
@@ -174,9 +147,6 @@
 //! you might need a blank space somewhere, try to pass an additional constraint and don't use the
 //! corresponding area.

-// show the feature flags in the generated documentation
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
-
 pub mod backend;
 pub mod buffer;
 pub mod layout;
--- a/src/style.rs
+++ b/src/style.rs
@@ -1,44 +1,8 @@
 //! `style` contains the primitives used to control how your user interface will look.
-//!
-//! # Using the `Style` struct
-//!
-//! This is useful when creating style variables.
-//! ## Example
-//! ```
-//! use ratatui::style::{Color, Modifier, Style};
-//!
-//! Style::default()
-//!    .fg(Color::Black)
-//!    .bg(Color::Green)
-//!    .add_modifier(Modifier::ITALIC | Modifier::BOLD);
-//! ```
-//!
-//! # Using style shorthands
-//!
-//! This is best for consise styling.
-//! ## Example
-//! ```
-//! use ratatui::{
-//!     style::{Color, Modifier, Style, Styled, Stylize},
-//!     text::Span,
-//! };
-//!
-//! assert_eq!(
-//!    "hello".red().on_blue().bold(),
-//!     Span::styled("hello", Style::default().fg(Color::Red).bg(Color::Blue).add_modifier(Modifier::BOLD))
-//! )
-//! ```
-mod stylized;
-
-use std::{
-    fmt::{self, Debug},
-    str::FromStr,
-};

 use bitflags::bitflags;
-pub use stylized::{Styled, Stylize};

-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Color {
    Reset,
@@ -70,12 +34,11 @@ bitflags! {
    /// ## Examples
    ///
    /// ```rust
-    /// # use ratatui::style::Modifier;
+    /// # use tui::style::Modifier;
    ///
    /// let m = Modifier::BOLD | Modifier::ITALIC;
    /// ```
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-    #[derive(Clone, Copy, PartialEq, Eq)]
    pub struct Modifier: u16 {
        const BOLD              = 0b0000_0000_0001;
        const DIM               = 0b0000_0000_0010;
@@ -89,24 +52,10 @@ bitflags! {
    }
 }

-/// Implement the `Debug` trait for `Modifier` manually.
-///
-/// This will avoid printing the empty modifier as 'Borders(0x0)' and instead print it as 'NONE'.
-impl fmt::Debug for Modifier {
-    /// Format the modifier as `NONE` if the modifier is empty or as a list of flags separated by
-    /// `|` otherwise.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if self.is_empty() {
-            return write!(f, "NONE");
-        }
-        fmt::Debug::fmt(&self.0, f)
-    }
-}
-
 /// Style let you control the main characteristics of the displayed elements.
 ///
 /// ```rust
-/// # use ratatui::style::{Color, Modifier, Style};
+/// # use tui::style::{Color, Modifier, Style};
 /// Style::default()
 ///     .fg(Color::Black)
 ///     .bg(Color::Green)
@@ -118,9 +67,9 @@ impl fmt::Debug for Modifier {
 /// just S3.
 ///
 /// ```rust
-/// # use ratatui::style::{Color, Modifier, Style};
-/// # use ratatui::buffer::Buffer;
-/// # use ratatui::layout::Rect;
+/// # use tui::style::{Color, Modifier, Style};
+/// # use tui::buffer::Buffer;
+/// # use tui::layout::Rect;
 /// let styles = [
 ///     Style::default().fg(Color::Blue).add_modifier(Modifier::BOLD | Modifier::ITALIC),
 ///     Style::default().bg(Color::Red),
@@ -145,9 +94,9 @@ impl fmt::Debug for Modifier {
 /// reset all properties until that point use [`Style::reset`].
 ///
 /// ```
-/// # use ratatui::style::{Color, Modifier, Style};
-/// # use ratatui::buffer::Buffer;
-/// # use ratatui::layout::Rect;
+/// # use tui::style::{Color, Modifier, Style};
+/// # use tui::buffer::Buffer;
+/// # use tui::layout::Rect;
 /// let styles = [
 ///     Style::default().fg(Color::Blue).add_modifier(Modifier::BOLD | Modifier::ITALIC),
 ///     Style::reset().fg(Color::Yellow),
@@ -166,7 +115,7 @@ impl fmt::Debug for Modifier {
 ///     buffer.get(0, 0).style(),
 /// );
 /// ```
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Style {
    pub fg: Option<Color>,
@@ -177,12 +126,6 @@ pub struct Style {

 impl Default for Style {
    fn default() -> Style {
-        Style::new()
-    }
-}
-
-impl Style {
-    pub const fn new() -> Style {
        Style {
            fg: None,
            bg: None,
@@ -190,9 +133,11 @@ impl Style {
            sub_modifier: Modifier::empty(),
        }
    }
+}

+impl Style {
    /// Returns a `Style` resetting all properties.
-    pub const fn reset() -> Style {
+    pub fn reset() -> Style {
        Style {
            fg: Some(Color::Reset),
            bg: Some(Color::Reset),
@@ -206,12 +151,12 @@ impl Style {
    /// ## Examples
    ///
    /// ```rust
-    /// # use ratatui::style::{Color, Style};
+    /// # use tui::style::{Color, Style};
    /// let style = Style::default().fg(Color::Blue);
    /// let diff = Style::default().fg(Color::Red);
    /// assert_eq!(style.patch(diff), Style::default().fg(Color::Red));
    /// ```
-    pub const fn fg(mut self, color: Color) -> Style {
+    pub fn fg(mut self, color: Color) -> Style {
        self.fg = Some(color);
        self
    }
@@ -221,12 +166,12 @@ impl Style {
    /// ## Examples
    ///
    /// ```rust
-    /// # use ratatui::style::{Color, Style};
+    /// # use tui::style::{Color, Style};
    /// let style = Style::default().bg(Color::Blue);
    /// let diff = Style::default().bg(Color::Red);
    /// assert_eq!(style.patch(diff), Style::default().bg(Color::Red));
    /// ```
-    pub const fn bg(mut self, color: Color) -> Style {
+    pub fn bg(mut self, color: Color) -> Style {
        self.bg = Some(color);
        self
    }
@@ -238,7 +183,7 @@ impl Style {
    /// ## Examples
    ///
    /// ```rust
-    /// # use ratatui::style::{Color, Modifier, Style};
+    /// # use tui::style::{Color, Modifier, Style};
    /// let style = Style::default().add_modifier(Modifier::BOLD);
    /// let diff = Style::default().add_modifier(Modifier::ITALIC);
    /// let patched = style.patch(diff);
@@ -258,7 +203,7 @@ impl Style {
    /// ## Examples
    ///
    /// ```rust
-    /// # use ratatui::style::{Color, Modifier, Style};
+    /// # use tui::style::{Color, Modifier, Style};
    /// let style = Style::default().add_modifier(Modifier::BOLD | Modifier::ITALIC);
    /// let diff = Style::default().remove_modifier(Modifier::ITALIC);
    /// let patched = style.patch(diff);
@@ -276,7 +221,7 @@ impl Style {
    ///
    /// ## Examples
    /// ```
-    /// # use ratatui::style::{Color, Modifier, Style};
+    /// # use tui::style::{Color, Modifier, Style};
    /// let style_1 = Style::default().fg(Color::Yellow);
    /// let style_2 = Style::default().bg(Color::Red);
    /// let combined = style_1.patch(style_2);
@@ -297,85 +242,6 @@ impl Style {
    }
 }

-/// Error type indicating a failure to parse a color string.
-#[derive(Debug)]
-pub struct ParseColorError;
-
-impl std::fmt::Display for ParseColorError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Failed to parse Colors")
-    }
-}
-
-impl std::error::Error for ParseColorError {}
-
-/// Converts a string representation to a `Color` instance.
-///
-/// The `from_str` function attempts to parse the given string and convert it
-/// to the corresponding `Color` variant. It supports named colors, RGB values,
-/// and indexed colors. If the string cannot be parsed, a `ParseColorError` is returned.
-///
-/// # Examples
-///
-/// ```
-/// # use std::str::FromStr;
-/// # use ratatui::style::Color;
-/// let color: Color = Color::from_str("blue").unwrap();
-/// assert_eq!(color, Color::Blue);
-///
-/// let color: Color = Color::from_str("#FF0000").unwrap();
-/// assert_eq!(color, Color::Rgb(255, 0, 0));
-///
-/// let color: Color = Color::from_str("10").unwrap();
-/// assert_eq!(color, Color::Indexed(10));
-///
-/// let color: Result<Color, _> = Color::from_str("invalid_color");
-/// assert!(color.is_err());
-/// ```
-impl FromStr for Color {
-    type Err = ParseColorError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(match s.to_lowercase().as_ref() {
-            "reset" => Self::Reset,
-            "black" => Self::Black,
-            "red" => Self::Red,
-            "green" => Self::Green,
-            "yellow" => Self::Yellow,
-            "blue" => Self::Blue,
-            "magenta" => Self::Magenta,
-            "cyan" => Self::Cyan,
-            "gray" => Self::Gray,
-            "darkgray" | "dark gray" => Self::DarkGray,
-            "lightred" | "light red" => Self::LightRed,
-            "lightgreen" | "light green" => Self::LightGreen,
-            "lightyellow" | "light yellow" => Self::LightYellow,
-            "lightblue" | "light blue" => Self::LightBlue,
-            "lightmagenta" | "light magenta" => Self::LightMagenta,
-            "lightcyan" | "light cyan" => Self::LightCyan,
-            "white" => Self::White,
-            _ => {
-                if let Ok(index) = s.parse::<u8>() {
-                    Self::Indexed(index)
-                } else if let (Ok(r), Ok(g), Ok(b)) = {
-                    if !s.starts_with('#') || s.len() != 7 {
-                        return Err(ParseColorError);
-                    }
-                    (
-                        u8::from_str_radix(&s[1..3], 16),
-                        u8::from_str_radix(&s[3..5], 16),
-                        u8::from_str_radix(&s[5..7], 16),
-                    )
-                } {
-                    Self::Rgb(r, g, b)
-                } else {
-                    return Err(ParseColorError);
-                }
-            }
-        })
-    }
-}
-
 #[cfg(test)]
 mod tests {
    use super::*;
@@ -412,97 +278,4 @@ mod tests {
            }
        }
    }
-
-    #[test]
-    fn combine_individual_modifiers() {
-        use crate::{buffer::Buffer, layout::Rect};
-
-        let mods = vec![
-            Modifier::BOLD,
-            Modifier::DIM,
-            Modifier::ITALIC,
-            Modifier::UNDERLINED,
-            Modifier::SLOW_BLINK,
-            Modifier::RAPID_BLINK,
-            Modifier::REVERSED,
-            Modifier::HIDDEN,
-            Modifier::CROSSED_OUT,
-        ];
-
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 1, 1));
-
-        for m in &mods {
-            buffer.get_mut(0, 0).set_style(Style::reset());
-            buffer
-                .get_mut(0, 0)
-                .set_style(Style::default().add_modifier(*m));
-            let style = buffer.get(0, 0).style();
-            assert!(style.add_modifier.contains(*m));
-            assert!(!style.sub_modifier.contains(*m));
-        }
-    }
-
-    #[test]
-    fn test_modifier_debug() {
-        assert_eq!(format!("{:?}", Modifier::empty()), "NONE");
-        assert_eq!(format!("{:?}", Modifier::BOLD), "BOLD");
-        assert_eq!(format!("{:?}", Modifier::DIM), "DIM");
-        assert_eq!(format!("{:?}", Modifier::ITALIC), "ITALIC");
-        assert_eq!(format!("{:?}", Modifier::UNDERLINED), "UNDERLINED");
-        assert_eq!(format!("{:?}", Modifier::SLOW_BLINK), "SLOW_BLINK");
-        assert_eq!(format!("{:?}", Modifier::RAPID_BLINK), "RAPID_BLINK");
-        assert_eq!(format!("{:?}", Modifier::REVERSED), "REVERSED");
-        assert_eq!(format!("{:?}", Modifier::HIDDEN), "HIDDEN");
-        assert_eq!(format!("{:?}", Modifier::CROSSED_OUT), "CROSSED_OUT");
-        assert_eq!(
-            format!("{:?}", Modifier::BOLD | Modifier::DIM),
-            "BOLD | DIM"
-        );
-        assert_eq!(
-            format!("{:?}", Modifier::all()),
-            "BOLD | DIM | ITALIC | UNDERLINED | SLOW_BLINK | RAPID_BLINK | REVERSED | HIDDEN | CROSSED_OUT"
-        );
-    }
-
-    #[test]
-    fn test_rgb_color() {
-        let color: Color = Color::from_str("#FF0000").unwrap();
-        assert_eq!(color, Color::Rgb(255, 0, 0));
-    }
-
-    #[test]
-    fn test_indexed_color() {
-        let color: Color = Color::from_str("10").unwrap();
-        assert_eq!(color, Color::Indexed(10));
-    }
-
-    #[test]
-    fn test_custom_color() {
-        let color: Color = Color::from_str("lightblue").unwrap();
-        assert_eq!(color, Color::LightBlue);
-    }
-
-    #[test]
-    fn test_invalid_colors() {
-        let bad_colors = [
-            "invalid_color", // not a color string
-            "abcdef0",       // 7 chars is not a color
-            " bcdefa",       // doesn't start with a '#'
-            "blue ",         // has space at end
-            " blue",         // has space at start
-            "#abcdef00",     // too many chars
-        ];
-
-        for bad_color in bad_colors {
-            assert!(
-                Color::from_str(bad_color).is_err(),
-                "bad color: '{bad_color}'"
-            );
-        }
-    }
-    #[test]
-    fn style_can_be_const() {
-        const _DEFAULT_STYLE: Style = Style::new().fg(Color::Red).bg(Color::Black);
-        const _RESET: Style = Style::reset();
-    }
 }
--- a/src/style/stylized.rs
+++ b/src/style/stylized.rs
@@ -1,228 +0,0 @@
-use crate::{
-    style::{Color, Modifier, Style},
-    text::Span,
-};
-
-pub trait Styled {
-    type Item;
-
-    fn style(&self) -> Style;
-    fn set_style(self, style: Style) -> Self::Item;
-}
-
-// Otherwise rustfmt behaves weirdly for some reason
-macro_rules! calculated_docs {
-    ($(#[doc = $doc:expr] $item:item)*) => { $(#[doc = $doc] $item)* };
-}
-
-macro_rules! modifier_method {
-    ($method_name:ident Modifier::$modifier:ident) => {
-        calculated_docs! {
-            #[doc = concat!(
-                "Applies the [`",
-                stringify!($modifier),
-                "`](crate::style::Modifier::",
-                stringify!($modifier),
-                ") modifier.",
-            )]
-            fn $method_name(self) -> T {
-                self.modifier(Modifier::$modifier)
-            }
-        }
-    };
-}
-
-macro_rules! color_method {
-    ($method_name_fg:ident, $method_name_bg:ident Color::$color:ident) => {
-        calculated_docs! {
-            #[doc = concat!(
-                "Sets the foreground color to [`",
-                stringify!($color),
-                "`](Color::",
-                stringify!($color),
-                ")."
-            )]
-            fn $method_name_fg(self) -> T {
-                self.fg(Color::$color)
-            }
-
-            #[doc = concat!(
-                "Sets the background color to [`",
-                stringify!($color),
-                "`](Color::",
-                stringify!($color),
-                ")."
-            )]
-            fn $method_name_bg(self) -> T {
-                self.bg(Color::$color)
-            }
-        }
-    };
-}
-
-/// The trait that enables something to be have a style.
-/// # Examples
-/// ```
-/// use ratatui::{
-///     style::{Color, Modifier, Style, Styled, Stylize},
-///     text::Span,
-/// };
-///
-/// assert_eq!(
-///    "hello".red().on_blue().bold(),
-///     Span::styled("hello", Style::default().fg(Color::Red).bg(Color::Blue).add_modifier(Modifier::BOLD))
-/// )
-pub trait Stylize<'a, T>: Sized {
-    // Colors
-    fn fg<S: Into<Color>>(self, color: S) -> T;
-    fn bg(self, color: Color) -> T;
-
-    color_method!(black, on_black Color::Black);
-    color_method!(red, on_red Color::Red);
-    color_method!(green, on_green Color::Green);
-    color_method!(yellow, on_yellow Color::Yellow);
-    color_method!(blue, on_blue Color::Blue);
-    color_method!(magenta, on_magenta Color::Magenta);
-    color_method!(cyan, on_cyan Color::Cyan);
-    color_method!(gray, on_gray Color::Gray);
-    color_method!(dark_gray, on_dark_gray Color::DarkGray);
-    color_method!(light_red, on_light_red Color::LightRed);
-    color_method!(light_green, on_light_green Color::LightGreen);
-    color_method!(light_yellow, on_light_yellow Color::LightYellow);
-    color_method!(light_blue, on_light_blue Color::LightBlue);
-    color_method!(light_magenta, on_light_magenta Color::LightMagenta);
-    color_method!(light_cyan, on_light_cyan Color::LightCyan);
-    color_method!(white, on_white Color::White);
-
-    // Styles
-    fn reset(self) -> T;
-
-    // Modifiers
-    fn modifier(self, modifier: Modifier) -> T;
-
-    modifier_method!(bold Modifier::BOLD);
-    modifier_method!(dimmed Modifier::DIM);
-    modifier_method!(italic Modifier::ITALIC);
-    modifier_method!(underline Modifier::UNDERLINED);
-    modifier_method!(slow_blink Modifier::SLOW_BLINK);
-    modifier_method!(rapid_blink Modifier::RAPID_BLINK);
-    modifier_method!(reversed Modifier::REVERSED);
-    modifier_method!(hidden Modifier::HIDDEN);
-    modifier_method!(crossed_out Modifier::CROSSED_OUT);
-}
-
-impl<'a, T, U> Stylize<'a, T> for U
-where
-    U: Styled<Item = T>,
-{
-    fn fg<S: Into<Color>>(self, color: S) -> T {
-        let style = self.style().fg(color.into());
-        self.set_style(style)
-    }
-
-    fn modifier(self, modifier: Modifier) -> T {
-        let style = self.style().add_modifier(modifier);
-        self.set_style(style)
-    }
-
-    fn bg(self, color: Color) -> T {
-        let style = self.style().bg(color);
-        self.set_style(style)
-    }
-
-    fn reset(self) -> T {
-        self.set_style(Style::default())
-    }
-}
-
-impl<'a> Styled for &'a str {
-    type Item = Span<'a>;
-
-    fn style(&self) -> Style {
-        Style::default()
-    }
-
-    fn set_style(self, style: Style) -> Self::Item {
-        Span::styled(self, style)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn reset() {
-        assert_eq!(
-            "hello".on_cyan().light_red().bold().underline().reset(),
-            Span::from("hello")
-        )
-    }
-
-    #[test]
-    fn fg() {
-        let cyan_fg = Style::default().fg(Color::Cyan);
-
-        assert_eq!("hello".cyan(), Span::styled("hello", cyan_fg));
-    }
-
-    #[test]
-    fn bg() {
-        let cyan_bg = Style::default().bg(Color::Cyan);
-
-        assert_eq!("hello".on_cyan(), Span::styled("hello", cyan_bg));
-    }
-
-    #[test]
-    fn color_modifier() {
-        let cyan_bold = Style::default()
-            .fg(Color::Cyan)
-            .add_modifier(Modifier::BOLD);
-
-        assert_eq!("hello".cyan().bold(), Span::styled("hello", cyan_bold))
-    }
-
-    #[test]
-    fn fg_bg() {
-        let cyan_fg_bg = Style::default().bg(Color::Cyan).fg(Color::Cyan);
-
-        assert_eq!("hello".cyan().on_cyan(), Span::styled("hello", cyan_fg_bg))
-    }
-
-    #[test]
-    fn repeated_attributes() {
-        let cyan_bg = Style::default().bg(Color::Cyan);
-        let cyan_fg = Style::default().fg(Color::Cyan);
-
-        // Behavior: the last one set is the definitive one
-        assert_eq!("hello".on_red().on_cyan(), Span::styled("hello", cyan_bg));
-        assert_eq!("hello".red().cyan(), Span::styled("hello", cyan_fg));
-    }
-
-    #[test]
-    fn all_chained() {
-        let all_modifier_black = Style::default()
-            .bg(Color::Black)
-            .fg(Color::Black)
-            .add_modifier(
-                Modifier::UNDERLINED
-                    | Modifier::BOLD
-                    | Modifier::DIM
-                    | Modifier::SLOW_BLINK
-                    | Modifier::REVERSED
-                    | Modifier::CROSSED_OUT,
-            );
-        assert_eq!(
-            "hello"
-                .on_black()
-                .black()
-                .bold()
-                .underline()
-                .dimmed()
-                .slow_blink()
-                .crossed_out()
-                .reversed(),
-            Span::styled("hello", all_modifier_black)
-        );
-    }
-}
--- a/src/symbols.rs
+++ b/src/symbols.rs
@@ -228,8 +228,6 @@ pub enum Marker {
    Dot,
    /// One point per cell in shape of a block
    Block,
-    /// One point per cell in the shape of a bar
-    Bar,
    /// Up to 8 points per cell
    Braille,
 }
--- a/src/terminal.rs
+++ b/src/terminal.rs
@@ -1,20 +1,36 @@
-use std::io;
-
 use crate::{
-    backend::{Backend, ClearType},
+    backend::Backend,
    buffer::Buffer,
    layout::Rect,
    widgets::{StatefulWidget, Widget},
 };
+use std::io;

-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Viewport {
-    Fullscreen,
-    Inline(u16),
-    Fixed(Rect),
+#[derive(Debug, Clone, PartialEq)]
+/// UNSTABLE
+enum ResizeBehavior {
+    Fixed,
+    Auto,
 }

-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
+/// UNSTABLE
+pub struct Viewport {
+    area: Rect,
+    resize_behavior: ResizeBehavior,
+}
+
+impl Viewport {
+    /// UNSTABLE
+    pub fn fixed(area: Rect) -> Viewport {
+        Viewport {
+            area,
+            resize_behavior: ResizeBehavior::Fixed,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
 /// Options to pass to [`Terminal::with_options`]
 pub struct TerminalOptions {
    /// Viewport used to draw to the terminal
@@ -37,12 +53,6 @@ where
    hidden_cursor: bool,
    /// Viewport
    viewport: Viewport,
-    viewport_area: Rect,
-    /// Last known size of the terminal. Used to detect if the internal buffers have to be resized.
-    last_known_size: Rect,
-    /// Last known position of the cursor. Used to find the new area when the viewport is inlined
-    /// and the terminal resized.
-    last_known_cursor_pos: (u16, u16),
 }

 /// Represents a consistent terminal interface for rendering.
@@ -63,21 +73,23 @@ impl<'a, B> Frame<'a, B>
 where
    B: Backend,
 {
-    /// Frame size, guaranteed not to change when rendering.
+    /// Terminal size, guaranteed not to change when rendering.
    pub fn size(&self) -> Rect {
-        self.terminal.viewport_area
+        self.terminal.viewport.area
    }

    /// Render a [`Widget`] to the current buffer using [`Widget::render`].
    ///
    /// # Examples
    ///
-    /// ```rust
-    /// # use ratatui::Terminal;
-    /// # use ratatui::backend::TestBackend;
-    /// # use ratatui::layout::Rect;
-    /// # use ratatui::widgets::Block;
-    /// # let backend = TestBackend::new(5, 5);
+    /// ```rust,no_run
+    /// # use std::io;
+    /// # use tui::Terminal;
+    /// # use tui::backend::TermionBackend;
+    /// # use tui::layout::Rect;
+    /// # use tui::widgets::Block;
+    /// # let stdout = io::stdout();
+    /// # let backend = TermionBackend::new(stdout);
    /// # let mut terminal = Terminal::new(backend).unwrap();
    /// let block = Block::default();
    /// let area = Rect::new(0, 0, 5, 5);
@@ -98,12 +110,14 @@ where
    ///
    /// # Examples
    ///
-    /// ```rust
-    /// # use ratatui::Terminal;
-    /// # use ratatui::backend::TestBackend;
-    /// # use ratatui::layout::Rect;
-    /// # use ratatui::widgets::{List, ListItem, ListState};
-    /// # let backend = TestBackend::new(5, 5);
+    /// ```rust,no_run
+    /// # use std::io;
+    /// # use tui::Terminal;
+    /// # use tui::backend::TermionBackend;
+    /// # use tui::layout::Rect;
+    /// # use tui::widgets::{List, ListItem, ListState};
+    /// # let stdout = io::stdout();
+    /// # let backend = TermionBackend::new(stdout);
    /// # let mut terminal = Terminal::new(backend).unwrap();
    /// let mut state = ListState::default();
    /// state.select(Some(1));
@@ -134,7 +148,7 @@ where
    }
 }

-/// `CompletedFrame` represents the state of the terminal after all changes performed in the last
+/// CompletedFrame represents the state of the terminal after all changes performed in the last
 /// [`Terminal::draw`] call have been applied. Therefore, it is only valid until the next call to
 /// [`Terminal::draw`].
 pub struct CompletedFrame<'a> {
@@ -150,7 +164,7 @@ where
        // Attempt to restore the cursor state
        if self.hidden_cursor {
            if let Err(err) = self.show_cursor() {
-                eprintln!("Failed to show the cursor: {err}");
+                eprintln!("Failed to show the cursor: {}", err);
            }
        }
    }
@@ -163,33 +177,29 @@ where
    /// Wrapper around Terminal initialization. Each buffer is initialized with a blank string and
    /// default colors for the foreground and the background
    pub fn new(backend: B) -> io::Result<Terminal<B>> {
+        let size = backend.size()?;
        Terminal::with_options(
            backend,
            TerminalOptions {
-                viewport: Viewport::Fullscreen,
+                viewport: Viewport {
+                    area: size,
+                    resize_behavior: ResizeBehavior::Auto,
+                },
            },
        )
    }

-    pub fn with_options(mut backend: B, options: TerminalOptions) -> io::Result<Terminal<B>> {
-        let size = match options.viewport {
-            Viewport::Fullscreen | Viewport::Inline(_) => backend.size()?,
-            Viewport::Fixed(area) => area,
-        };
-        let (viewport_area, cursor_pos) = match options.viewport {
-            Viewport::Fullscreen => (size, (0, 0)),
-            Viewport::Inline(height) => compute_inline_size(&mut backend, height, size, 0)?,
-            Viewport::Fixed(area) => (area, (area.left(), area.top())),
-        };
+    /// UNSTABLE
+    pub fn with_options(backend: B, options: TerminalOptions) -> io::Result<Terminal<B>> {
        Ok(Terminal {
            backend,
-            buffers: [Buffer::empty(viewport_area), Buffer::empty(viewport_area)],
+            buffers: [
+                Buffer::empty(options.viewport.area),
+                Buffer::empty(options.viewport.area),
+            ],
            current: 0,
            hidden_cursor: false,
            viewport: options.viewport,
-            viewport_area,
-            last_known_size: size,
-            last_known_cursor_pos: cursor_pos,
        })
    }

@@ -219,46 +229,24 @@ where
        let previous_buffer = &self.buffers[1 - self.current];
        let current_buffer = &self.buffers[self.current];
        let updates = previous_buffer.diff(current_buffer);
-        if let Some((col, row, _)) = updates.last() {
-            self.last_known_cursor_pos = (*col, *row);
-        }
        self.backend.draw(updates.into_iter())
    }

    /// Updates the Terminal so that internal buffers match the requested size. Requested size will
    /// be saved so the size can remain consistent when rendering.
    /// This leads to a full clear of the screen.
-    pub fn resize(&mut self, size: Rect) -> io::Result<()> {
-        let next_area = match self.viewport {
-            Viewport::Fullscreen => size,
-            Viewport::Inline(height) => {
-                let offset_in_previous_viewport = self
-                    .last_known_cursor_pos
-                    .1
-                    .saturating_sub(self.viewport_area.top());
-                compute_inline_size(&mut self.backend, height, size, offset_in_previous_viewport)?.0
-            }
-            Viewport::Fixed(area) => area,
-        };
-        self.set_viewport_area(next_area);
-        self.clear()?;
-
-        self.last_known_size = size;
-        Ok(())
-    }
-
-    fn set_viewport_area(&mut self, area: Rect) {
+    pub fn resize(&mut self, area: Rect) -> io::Result<()> {
        self.buffers[self.current].resize(area);
        self.buffers[1 - self.current].resize(area);
-        self.viewport_area = area;
+        self.viewport.area = area;
+        self.clear()
    }

    /// Queries the backend for size and resizes if it doesn't match the previous size.
    pub fn autoresize(&mut self) -> io::Result<()> {
-        // fixed viewports do not get autoresized
-        if matches!(self.viewport, Viewport::Fullscreen | Viewport::Inline(_)) {
+        if self.viewport.resize_behavior == ResizeBehavior::Auto {
            let size = self.size()?;
-            if size != self.last_known_size {
+            if size != self.viewport.area {
                self.resize(size)?;
            }
        };
@@ -293,14 +281,15 @@ where
            }
        }

-        self.swap_buffers();
+        // Swap buffers
+        self.buffers[1 - self.current].reset();
+        self.current = 1 - self.current;

        // Flush
        self.backend.flush()?;
-
        Ok(CompletedFrame {
            buffer: &self.buffers[1 - self.current],
-            area: self.last_known_size,
+            area: self.viewport.area,
        })
    }

@@ -321,166 +310,19 @@ where
    }

    pub fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
-        self.backend.set_cursor(x, y)?;
-        self.last_known_cursor_pos = (x, y);
-        Ok(())
+        self.backend.set_cursor(x, y)
    }

    /// Clear the terminal and force a full redraw on the next draw call.
    pub fn clear(&mut self) -> io::Result<()> {
-        match self.viewport {
-            Viewport::Fullscreen => self.backend.clear_region(ClearType::All)?,
-            Viewport::Inline(_) => {
-                self.backend
-                    .set_cursor(self.viewport_area.left(), self.viewport_area.top())?;
-                self.backend.clear_region(ClearType::AfterCursor)?;
-            }
-            Viewport::Fixed(area) => {
-                for row in area.top()..area.bottom() {
-                    self.backend.set_cursor(0, row)?;
-                    self.backend.clear_region(ClearType::AfterCursor)?;
-                }
-            }
-        }
+        self.backend.clear()?;
        // Reset the back buffer to make sure the next update will redraw everything.
        self.buffers[1 - self.current].reset();
        Ok(())
    }

-    /// Clears the inactive buffer and swaps it with the current buffer
-    pub fn swap_buffers(&mut self) {
-        self.buffers[1 - self.current].reset();
-        self.current = 1 - self.current;
-    }
-
    /// Queries the real size of the backend.
    pub fn size(&self) -> io::Result<Rect> {
        self.backend.size()
    }
-
-    /// Insert some content before the current inline viewport. This has no effect when the
-    /// viewport is fullscreen.
-    ///
-    /// This function scrolls down the current viewport by the given height. The newly freed space
-    /// is then made available to the `draw_fn` closure through a writable `Buffer`.
-    ///
-    /// Before:
-    /// ```ignore
-    /// +-------------------+
-    /// |                   |
-    /// |      viewport     |
-    /// |                   |
-    /// +-------------------+
-    /// ```
-    ///
-    /// After:
-    /// ```ignore
-    /// +-------------------+
-    /// |      buffer       |
-    /// +-------------------+
-    /// +-------------------+
-    /// |                   |
-    /// |      viewport     |
-    /// |                   |
-    /// +-------------------+
-    /// ```
-    ///
-    /// # Examples
-    ///
-    /// ## Insert a single line before the current viewport
-    ///
-    /// ```rust
-    /// # use ratatui::widgets::{Paragraph, Widget};
-    /// # use ratatui::text::{Line, Span};
-    /// # use ratatui::style::{Color, Style};
-    /// # use ratatui::{Terminal};
-    /// # use ratatui::backend::TestBackend;
-    /// # let backend = TestBackend::new(10, 10);
-    /// # let mut terminal = Terminal::new(backend).unwrap();
-    /// terminal.insert_before(1, |buf| {
-    ///     Paragraph::new(Line::from(vec![
-    ///         Span::raw("This line will be added "),
-    ///         Span::styled("before", Style::default().fg(Color::Blue)),
-    ///         Span::raw(" the current viewport")
-    ///     ])).render(buf.area, buf);
-    /// });
-    /// ```
-    pub fn insert_before<F>(&mut self, height: u16, draw_fn: F) -> io::Result<()>
-    where
-        F: FnOnce(&mut Buffer),
-    {
-        if !matches!(self.viewport, Viewport::Inline(_)) {
-            return Ok(());
-        }
-
-        self.clear()?;
-        let height = height.min(self.last_known_size.height);
-        self.backend.append_lines(height)?;
-        let missing_lines =
-            height.saturating_sub(self.last_known_size.bottom() - self.viewport_area.top());
-        let area = Rect {
-            x: self.viewport_area.left(),
-            y: self.viewport_area.top().saturating_sub(missing_lines),
-            width: self.viewport_area.width,
-            height,
-        };
-        let mut buffer = Buffer::empty(area);
-
-        draw_fn(&mut buffer);
-
-        let iter = buffer.content.iter().enumerate().map(|(i, c)| {
-            let (x, y) = buffer.pos_of(i);
-            (x, y, c)
-        });
-        self.backend.draw(iter)?;
-        self.backend.flush()?;
-
-        let remaining_lines = self.last_known_size.height - area.bottom();
-        let missing_lines = self.viewport_area.height.saturating_sub(remaining_lines);
-        self.backend.append_lines(self.viewport_area.height)?;
-
-        self.set_viewport_area(Rect {
-            x: area.left(),
-            y: area.bottom().saturating_sub(missing_lines),
-            width: area.width,
-            height: self.viewport_area.height,
-        });
-
-        Ok(())
-    }
-}
-
-fn compute_inline_size<B: Backend>(
-    backend: &mut B,
-    height: u16,
-    size: Rect,
-    offset_in_previous_viewport: u16,
-) -> io::Result<(Rect, (u16, u16))> {
-    let pos = backend.get_cursor()?;
-    let mut row = pos.1;
-
-    let max_height = size.height.min(height);
-
-    let lines_after_cursor = height
-        .saturating_sub(offset_in_previous_viewport)
-        .saturating_sub(1);
-
-    backend.append_lines(lines_after_cursor)?;
-
-    let available_lines = size.height.saturating_sub(row).saturating_sub(1);
-    let missing_lines = lines_after_cursor.saturating_sub(available_lines);
-    if missing_lines > 0 {
-        row = row.saturating_sub(missing_lines);
-    }
-    row = row.saturating_sub(offset_in_previous_viewport);
-
-    Ok((
-        Rect {
-            x: 0,
-            y: row,
-            width: size.width,
-            height: max_height,
-        },
-        pos,
-    ))
 }
--- a/src/text.rs
+++ b/src/text.rs
@@ -1,35 +1,35 @@
 //! Primitives for styled text.
 //!
 //! A terminal UI is at its root a lot of strings. In order to make it accessible and stylish,
-//! those strings may be associated to a set of styles. `ratatui` has three ways to represent them:
+//! those strings may be associated to a set of styles. `tui` has three ways to represent them:
 //! - A single line string where all graphemes have the same style is represented by a [`Span`].
-//! - A single line string where each grapheme may have its own style is represented by [`Line`].
+//! - A single line string where each grapheme may have its own style is represented by [`Spans`].
 //! - A multiple line string where each grapheme may have its own style is represented by a
 //! [`Text`].
 //!
-//! These types form a hierarchy: [`Line`] is a collection of [`Span`] and each line of [`Text`]
-//! is a [`Line`].
+//! These types form a hierarchy: [`Spans`] is a collection of [`Span`] and each line of [`Text`]
+//! is a [`Spans`].
 //!
 //! Keep it mind that a lot of widgets will use those types to advertise what kind of string is
-//! supported for their properties. Moreover, `ratatui` provides convenient `From` implementations
-//! so that you can start by using simple `String` or `&str` and then promote them to the previous
+//! supported for their properties. Moreover, `tui` provides convenient `From` implementations so
+//! that you can start by using simple `String` or `&str` and then promote them to the previous
 //! primitives when you need additional styling capabilities.
 //!
 //! For example, for the [`crate::widgets::Block`] widget, all the following calls are valid to set
-//! its `title` property (which is a [`Line`] under the hood):
+//! its `title` property (which is a [`Spans`] under the hood):
 //!
 //! ```rust
-//! # use ratatui::widgets::Block;
-//! # use ratatui::text::{Span, Line};
-//! # use ratatui::style::{Color, Style};
+//! # use tui::widgets::Block;
+//! # use tui::text::{Span, Spans};
+//! # use tui::style::{Color, Style};
 //! // A simple string with no styling.
-//! // Converted to Line(vec![
+//! // Converted to Spans(vec![
 //! //   Span { content: Cow::Borrowed("My title"), style: Style { .. } }
 //! // ])
 //! let block = Block::default().title("My title");
 //!
 //! // A simple string with a unique style.
-//! // Converted to Line(vec![
+//! // Converted to Spans(vec![
 //! //   Span { content: Cow::Borrowed("My title"), style: Style { fg: Some(Color::Yellow), .. }
 //! // ])
 //! let block = Block::default().title(
@@ -37,7 +37,7 @@
 //! );
 //!
 //! // A string with multiple styles.
-//! // Converted to Line(vec![
+//! // Converted to Spans(vec![
 //! //   Span { content: Cow::Borrowed("My"), style: Style { fg: Some(Color::Yellow), .. } },
 //! //   Span { content: Cow::Borrowed(" title"), .. }
 //! // ])
@@ -46,28 +46,20 @@
 //!     Span::raw(" title"),
 //! ]);
 //! ```
-use std::{borrow::Cow, fmt::Debug};
-
+use crate::style::Style;
+use std::borrow::Cow;
 use unicode_segmentation::UnicodeSegmentation;
 use unicode_width::UnicodeWidthStr;

-use crate::style::{Style, Styled};
-
-mod line;
-mod masked;
-mod spans;
-#[allow(deprecated)]
-pub use {line::Line, masked::Masked, spans::Spans};
-
 /// A grapheme associated to a style.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct StyledGrapheme<'a> {
    pub symbol: &'a str,
    pub style: Style,
 }

 /// A string where all graphemes have the same style.
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Span<'a> {
    pub content: Cow<'a, str>,
    pub style: Style,
@@ -79,7 +71,7 @@ impl<'a> Span<'a> {
    /// ## Examples
    ///
    /// ```rust
-    /// # use ratatui::text::Span;
+    /// # use tui::text::Span;
    /// Span::raw("My text");
    /// Span::raw(String::from("My text"));
    /// ```
@@ -98,8 +90,8 @@ impl<'a> Span<'a> {
    /// # Examples
    ///
    /// ```rust
-    /// # use ratatui::text::Span;
-    /// # use ratatui::style::{Color, Modifier, Style};
+    /// # use tui::text::Span;
+    /// # use tui::style::{Color, Modifier, Style};
    /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
    /// Span::styled("My text", style);
    /// Span::styled(String::from("My text"), style);
@@ -127,8 +119,8 @@ impl<'a> Span<'a> {
    /// ## Examples
    ///
    /// ```rust
-    /// # use ratatui::text::{Span, StyledGrapheme};
-    /// # use ratatui::style::{Color, Modifier, Style};
+    /// # use tui::text::{Span, StyledGrapheme};
+    /// # use tui::style::{Color, Modifier, Style};
    /// # use std::iter::Iterator;
    /// let style = Style::default().fg(Color::Yellow);
    /// let span = Span::styled("Text", style);
@@ -187,43 +179,6 @@ impl<'a> Span<'a> {
            })
            .filter(|s| s.symbol != "\n")
    }
-
-    /// Patches the style an existing Span, adding modifiers from the given style.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use ratatui::text::Span;
-    /// # use ratatui::style::{Color, Style, Modifier};
-    /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
-    /// let mut raw_span = Span::raw("My text");
-    /// let mut styled_span = Span::styled("My text", style);
-    ///
-    /// assert_ne!(raw_span, styled_span);
-    ///
-    /// raw_span.patch_style(style);
-    /// assert_eq!(raw_span, styled_span);
-    /// ```
-    pub fn patch_style(&mut self, style: Style) {
-        self.style = self.style.patch(style);
-    }
-
-    /// Resets the style of the Span.
-    /// Equivalent to calling `patch_style(Style::reset())`.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use ratatui::text::Span;
-    /// # use ratatui::style::{Color, Style, Modifier};
-    /// let mut span = Span::styled("My text", Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC));
-    ///
-    /// span.reset_style();
-    /// assert_eq!(Style::reset(), span.style);
-    /// ```
-    pub fn reset_style(&mut self) {
-        self.patch_style(Style::reset());
-    }
 }

 impl<'a> From<String> for Span<'a> {
@@ -238,14 +193,65 @@ impl<'a> From<&'a str> for Span<'a> {
    }
 }

-impl<'a> Styled for Span<'a> {
-    type Item = Span<'a>;
-    fn style(&self) -> Style {
-        self.style
-    }
+/// A string composed of clusters of graphemes, each with their own style.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Spans<'a>(pub Vec<Span<'a>>);

-    fn set_style(self, style: Style) -> Self {
-        Self::styled(self.content, style)
+impl<'a> Default for Spans<'a> {
+    fn default() -> Spans<'a> {
+        Spans(Vec::new())
+    }
+}
+
+impl<'a> Spans<'a> {
+    /// Returns the width of the underlying string.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use tui::text::{Span, Spans};
+    /// # use tui::style::{Color, Style};
+    /// let spans = Spans::from(vec![
+    ///     Span::styled("My", Style::default().fg(Color::Yellow)),
+    ///     Span::raw(" text"),
+    /// ]);
+    /// assert_eq!(7, spans.width());
+    /// ```
+    pub fn width(&self) -> usize {
+        self.0.iter().map(Span::width).sum()
+    }
+}
+
+impl<'a> From<String> for Spans<'a> {
+    fn from(s: String) -> Spans<'a> {
+        Spans(vec![Span::from(s)])
+    }
+}
+
+impl<'a> From<&'a str> for Spans<'a> {
+    fn from(s: &'a str) -> Spans<'a> {
+        Spans(vec![Span::from(s)])
+    }
+}
+
+impl<'a> From<Vec<Span<'a>>> for Spans<'a> {
+    fn from(spans: Vec<Span<'a>>) -> Spans<'a> {
+        Spans(spans)
+    }
+}
+
+impl<'a> From<Span<'a>> for Spans<'a> {
+    fn from(span: Span<'a>) -> Spans<'a> {
+        Spans(vec![span])
+    }
+}
+
+impl<'a> From<Spans<'a>> for String {
+    fn from(line: Spans<'a>) -> String {
+        line.0.iter().fold(String::new(), |mut acc, s| {
+            acc.push_str(s.content.as_ref());
+            acc
+        })
    }
 }

@@ -257,8 +263,8 @@ impl<'a> Styled for Span<'a> {
 /// [`core::iter::Extend`] which enables the concatenation of several [`Text`] blocks.
 ///
 /// ```rust
-/// # use ratatui::text::Text;
-/// # use ratatui::style::{Color, Modifier, Style};
+/// # use tui::text::Text;
+/// # use tui::style::{Color, Modifier, Style};
 /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
 ///
 /// // An initial two lines of `Text` built from a `&str`
@@ -273,9 +279,15 @@ impl<'a> Styled for Span<'a> {
 /// text.extend(Text::styled("Some more lines\nnow with more style!", style));
 /// assert_eq!(6, text.height());
 /// ```
-#[derive(Debug, Clone, PartialEq, Default, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Text<'a> {
-    pub lines: Vec<Line<'a>>,
+    pub lines: Vec<Spans<'a>>,
+}
+
+impl<'a> Default for Text<'a> {
+    fn default() -> Text<'a> {
+        Text { lines: Vec::new() }
+    }
 }

 impl<'a> Text<'a> {
@@ -284,7 +296,7 @@ impl<'a> Text<'a> {
    /// ## Examples
    ///
    /// ```rust
-    /// # use ratatui::text::Text;
+    /// # use tui::text::Text;
    /// Text::raw("The first line\nThe second line");
    /// Text::raw(String::from("The first line\nThe second line"));
    /// ```
@@ -292,14 +304,12 @@ impl<'a> Text<'a> {
    where
        T: Into<Cow<'a, str>>,
    {
-        let lines: Vec<_> = match content.into() {
-            Cow::Borrowed("") => vec![Line::from("")],
-            Cow::Borrowed(s) => s.lines().map(Line::from).collect(),
-            Cow::Owned(s) if s.is_empty() => vec![Line::from("")],
-            Cow::Owned(s) => s.lines().map(|l| Line::from(l.to_owned())).collect(),
-        };
-
-        Text::from(lines)
+        Text {
+            lines: match content.into() {
+                Cow::Borrowed(s) => s.lines().map(Spans::from).collect(),
+                Cow::Owned(s) => s.lines().map(|l| Spans::from(l.to_owned())).collect(),
+            },
+        }
    }

    /// Create some text (potentially multiple lines) with a style.
@@ -307,8 +317,8 @@ impl<'a> Text<'a> {
    /// # Examples
    ///
    /// ```rust
-    /// # use ratatui::text::Text;
-    /// # use ratatui::style::{Color, Modifier, Style};
+    /// # use tui::text::Text;
+    /// # use tui::style::{Color, Modifier, Style};
    /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
    /// Text::styled("The first line\nThe second line", style);
    /// Text::styled(String::from("The first line\nThe second line"), style);
@@ -327,12 +337,16 @@ impl<'a> Text<'a> {
    /// ## Examples
    ///
    /// ```rust
-    /// use ratatui::text::Text;
+    /// use tui::text::Text;
    /// let text = Text::from("The first line\nThe second line");
    /// assert_eq!(15, text.width());
    /// ```
    pub fn width(&self) -> usize {
-        self.lines.iter().map(Line::width).max().unwrap_or_default()
+        self.lines
+            .iter()
+            .map(Spans::width)
+            .max()
+            .unwrap_or_default()
    }

    /// Returns the height.
@@ -340,7 +354,7 @@ impl<'a> Text<'a> {
    /// ## Examples
    ///
    /// ```rust
-    /// use ratatui::text::Text;
+    /// use tui::text::Text;
    /// let text = Text::from("The first line\nThe second line");
    /// assert_eq!(2, text.height());
    /// ```
@@ -348,13 +362,13 @@ impl<'a> Text<'a> {
        self.lines.len()
    }

-    /// Patches the style of each line in an existing Text, adding modifiers from the given style.
+    /// Apply a new style to existing text.
    ///
    /// # Examples
    ///
    /// ```rust
-    /// # use ratatui::text::Text;
-    /// # use ratatui::style::{Color, Modifier, Style};
+    /// # use tui::text::Text;
+    /// # use tui::style::{Color, Modifier, Style};
    /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
    /// let mut raw_text = Text::raw("The first line\nThe second line");
    /// let styled_text = Text::styled(String::from("The first line\nThe second line"), style);
@@ -365,31 +379,9 @@ impl<'a> Text<'a> {
    /// ```
    pub fn patch_style(&mut self, style: Style) {
        for line in &mut self.lines {
-            line.patch_style(style);
-        }
-    }
-
-    /// Resets the style of the Text.
-    /// Equivalent to calling `patch_style(Style::reset())`.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use ratatui::text::{Span, Line, Text};
-    /// # use ratatui::style::{Color, Style, Modifier};
-    /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
-    /// let mut text = Text::styled("The first line\nThe second line", style);
-    ///
-    /// text.reset_style();
-    /// for line in &text.lines {
-    ///     for span in &line.spans {
-    ///         assert_eq!(Style::reset(), span.style);
-    ///     }
-    /// }
-    /// ```
-    pub fn reset_style(&mut self) {
-        for line in &mut self.lines {
-            line.reset_style();
+            for span in &mut line.0 {
+                span.style = span.style.patch(style);
+            }
        }
    }
 }
@@ -415,43 +407,25 @@ impl<'a> From<Cow<'a, str>> for Text<'a> {
 impl<'a> From<Span<'a>> for Text<'a> {
    fn from(span: Span<'a>) -> Text<'a> {
        Text {
-            lines: vec![Line::from(span)],
+            lines: vec![Spans::from(span)],
        }
    }
 }

-#[allow(deprecated)]
 impl<'a> From<Spans<'a>> for Text<'a> {
    fn from(spans: Spans<'a>) -> Text<'a> {
-        Text {
-            lines: vec![spans.into()],
-        }
+        Text { lines: vec![spans] }
    }
 }

-impl<'a> From<Line<'a>> for Text<'a> {
-    fn from(line: Line<'a>) -> Text<'a> {
-        Text { lines: vec![line] }
-    }
-}
-
-#[allow(deprecated)]
 impl<'a> From<Vec<Spans<'a>>> for Text<'a> {
    fn from(lines: Vec<Spans<'a>>) -> Text<'a> {
-        Text {
-            lines: lines.into_iter().map(|l| l.0.into()).collect(),
-        }
-    }
-}
-
-impl<'a> From<Vec<Line<'a>>> for Text<'a> {
-    fn from(lines: Vec<Line<'a>>) -> Text<'a> {
        Text { lines }
    }
 }

 impl<'a> IntoIterator for Text<'a> {
-    type Item = Line<'a>;
+    type Item = Spans<'a>;
    type IntoIter = std::vec::IntoIter<Self::Item>;

    fn into_iter(self) -> Self::IntoIter {
@@ -459,12 +433,8 @@ impl<'a> IntoIterator for Text<'a> {
    }
 }

-impl<'a, T> Extend<T> for Text<'a>
-where
-    T: Into<Line<'a>>,
-{
-    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
-        let lines = iter.into_iter().map(Into::into);
-        self.lines.extend(lines);
+impl<'a> Extend<Spans<'a>> for Text<'a> {
+    fn extend<T: IntoIterator<Item = Spans<'a>>>(&mut self, iter: T) {
+        self.lines.extend(iter);
    }
 }
--- a/src/text/line.rs
+++ b/src/text/line.rs
@@ -1,251 +0,0 @@
-#![allow(deprecated)]
-use super::{Span, Spans, Style};
-use crate::layout::Alignment;
-
-#[derive(Debug, Clone, PartialEq, Default, Eq)]
-pub struct Line<'a> {
-    pub spans: Vec<Span<'a>>,
-    pub alignment: Option<Alignment>,
-}
-
-impl<'a> Line<'a> {
-    /// Returns the width of the underlying string.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use ratatui::text::{Span, Line};
-    /// # use ratatui::style::{Color, Style};
-    /// let line = Line::from(vec![
-    ///     Span::styled("My", Style::default().fg(Color::Yellow)),
-    ///     Span::raw(" text"),
-    /// ]);
-    /// assert_eq!(7, line.width());
-    /// ```
-    pub fn width(&self) -> usize {
-        self.spans.iter().map(Span::width).sum()
-    }
-
-    /// Patches the style of each Span in an existing Line, adding modifiers from the given style.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use ratatui::text::{Span, Line};
-    /// # use ratatui::style::{Color, Style, Modifier};
-    /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
-    /// let mut raw_line = Line::from(vec![
-    ///     Span::raw("My"),
-    ///     Span::raw(" text"),
-    /// ]);
-    /// let mut styled_line = Line::from(vec![
-    ///     Span::styled("My", style),
-    ///     Span::styled(" text", style),
-    /// ]);
-    ///
-    /// assert_ne!(raw_line, styled_line);
-    ///
-    /// raw_line.patch_style(style);
-    /// assert_eq!(raw_line, styled_line);
-    /// ```
-    pub fn patch_style(&mut self, style: Style) {
-        for span in &mut self.spans {
-            span.patch_style(style);
-        }
-    }
-
-    /// Resets the style of each Span in the Line.
-    /// Equivalent to calling `patch_style(Style::reset())`.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use ratatui::text::{Span, Line};
-    /// # use ratatui::style::{Color, Style, Modifier};
-    /// let mut line = Line::from(vec![
-    ///     Span::styled("My", Style::default().fg(Color::Yellow)),
-    ///     Span::styled(" text", Style::default().add_modifier(Modifier::BOLD)),
-    /// ]);
-    ///
-    /// line.reset_style();
-    /// assert_eq!(Style::reset(), line.spans[0].style);
-    /// assert_eq!(Style::reset(), line.spans[1].style);
-    /// ```
-    pub fn reset_style(&mut self) {
-        for span in &mut self.spans {
-            span.reset_style();
-        }
-    }
-
-    /// Sets the target alignment for this line of text.
-    /// Defaults to: [`None`], meaning the alignment is determined by the rendering widget.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use std::borrow::Cow;
-    /// # use ratatui::layout::Alignment;
-    /// # use ratatui::text::{Span, Line};
-    /// # use ratatui::style::{Color, Style, Modifier};
-    /// let mut line = Line::from("Hi, what's up?");
-    /// assert_eq!(None, line.alignment);
-    /// assert_eq!(Some(Alignment::Right), line.alignment(Alignment::Right).alignment)
-    /// ```
-    pub fn alignment(self, alignment: Alignment) -> Self {
-        Self {
-            alignment: Some(alignment),
-            ..self
-        }
-    }
-}
-
-impl<'a> From<String> for Line<'a> {
-    fn from(s: String) -> Self {
-        Self::from(vec![Span::from(s)])
-    }
-}
-
-impl<'a> From<&'a str> for Line<'a> {
-    fn from(s: &'a str) -> Self {
-        Self::from(vec![Span::from(s)])
-    }
-}
-
-impl<'a> From<Vec<Span<'a>>> for Line<'a> {
-    fn from(spans: Vec<Span<'a>>) -> Self {
-        Self {
-            spans,
-            ..Default::default()
-        }
-    }
-}
-
-impl<'a> From<Span<'a>> for Line<'a> {
-    fn from(span: Span<'a>) -> Self {
-        Self::from(vec![span])
-    }
-}
-
-impl<'a> From<Line<'a>> for String {
-    fn from(line: Line<'a>) -> String {
-        line.spans.iter().fold(String::new(), |mut acc, s| {
-            acc.push_str(s.content.as_ref());
-            acc
-        })
-    }
-}
-
-impl<'a> From<Spans<'a>> for Line<'a> {
-    fn from(value: Spans<'a>) -> Self {
-        Self::from(value.0)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{
-        layout::Alignment,
-        style::{Color, Modifier, Style},
-        text::{Line, Span, Spans},
-    };
-
-    #[test]
-    fn test_width() {
-        let line = Line::from(vec![
-            Span::styled("My", Style::default().fg(Color::Yellow)),
-            Span::raw(" text"),
-        ]);
-        assert_eq!(7, line.width());
-
-        let empty_line = Line::default();
-        assert_eq!(0, empty_line.width());
-    }
-
-    #[test]
-    fn test_patch_style() {
-        let style = Style::default()
-            .fg(Color::Yellow)
-            .add_modifier(Modifier::ITALIC);
-        let mut raw_line = Line::from(vec![Span::raw("My"), Span::raw(" text")]);
-        let styled_line = Line::from(vec![
-            Span::styled("My", style),
-            Span::styled(" text", style),
-        ]);
-
-        assert_ne!(raw_line, styled_line);
-
-        raw_line.patch_style(style);
-        assert_eq!(raw_line, styled_line);
-    }
-
-    #[test]
-    fn test_reset_style() {
-        let mut line = Line::from(vec![
-            Span::styled("My", Style::default().fg(Color::Yellow)),
-            Span::styled(" text", Style::default().add_modifier(Modifier::BOLD)),
-        ]);
-
-        line.reset_style();
-        assert_eq!(Style::reset(), line.spans[0].style);
-        assert_eq!(Style::reset(), line.spans[1].style);
-    }
-
-    #[test]
-    fn test_from_string() {
-        let s = String::from("Hello, world!");
-        let line = Line::from(s);
-        assert_eq!(vec![Span::from("Hello, world!")], line.spans);
-    }
-
-    #[test]
-    fn test_from_str() {
-        let s = "Hello, world!";
-        let line = Line::from(s);
-        assert_eq!(vec![Span::from("Hello, world!")], line.spans);
-    }
-
-    #[test]
-    fn test_from_vec() {
-        let spans = vec![
-            Span::styled("Hello,", Style::default().fg(Color::Red)),
-            Span::styled(" world!", Style::default().fg(Color::Green)),
-        ];
-        let line = Line::from(spans.clone());
-        assert_eq!(spans, line.spans);
-    }
-
-    #[test]
-    fn test_from_span() {
-        let span = Span::styled("Hello, world!", Style::default().fg(Color::Yellow));
-        let line = Line::from(span.clone());
-        assert_eq!(vec![span], line.spans);
-    }
-
-    #[test]
-    fn test_from_spans() {
-        let spans = vec![
-            Span::styled("Hello,", Style::default().fg(Color::Red)),
-            Span::styled(" world!", Style::default().fg(Color::Green)),
-        ];
-        assert_eq!(Line::from(Spans::from(spans.clone())), Line::from(spans));
-    }
-
-    #[test]
-    fn test_into_string() {
-        let line = Line::from(vec![
-            Span::styled("Hello,", Style::default().fg(Color::Red)),
-            Span::styled(" world!", Style::default().fg(Color::Green)),
-        ]);
-        let s: String = line.into();
-        assert_eq!("Hello, world!", s);
-    }
-
-    #[test]
-    fn test_alignment() {
-        let line = Line::from("This is left").alignment(Alignment::Left);
-        assert_eq!(Some(Alignment::Left), line.alignment);
-
-        let line = Line::from("This is default");
-        assert_eq!(None, line.alignment);
-    }
-}
--- a/src/text/masked.rs
+++ b/src/text/masked.rs
@@ -1,128 +0,0 @@
-use std::{
-    borrow::Cow,
-    fmt::{self, Debug, Display},
-};
-
-use super::Text;
-
-/// A wrapper around a string that is masked when displayed.
-///
-/// The masked string is displayed as a series of the same character.
-/// This might be used to display a password field or similar secure data.
-///
-/// # Examples
-///
-/// ```rust
-/// use ratatui::{buffer::Buffer, layout::Rect, text::Masked, widgets::{Paragraph, Widget}};
-///
-/// let mut buffer = Buffer::empty(Rect::new(0, 0, 5, 1));
-/// let password = Masked::new("12345", 'x');
-///
-/// Paragraph::new(password).render(buffer.area, &mut buffer);
-/// assert_eq!(buffer, Buffer::with_lines(vec!["xxxxx"]));
-/// ```
-#[derive(Clone)]
-pub struct Masked<'a> {
-    inner: Cow<'a, str>,
-    mask_char: char,
-}
-
-impl<'a> Masked<'a> {
-    pub fn new(s: impl Into<Cow<'a, str>>, mask_char: char) -> Self {
-        Self {
-            inner: s.into(),
-            mask_char,
-        }
-    }
-
-    /// The character to use for masking.
-    pub fn mask_char(&self) -> char {
-        self.mask_char
-    }
-
-    /// The underlying string, with all characters masked.
-    pub fn value(&self) -> Cow<'a, str> {
-        self.inner.chars().map(|_| self.mask_char).collect()
-    }
-}
-
-impl Debug for Masked<'_> {
-    /// Debug representation of a masked string is the underlying string
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(&self.inner).map_err(|_| fmt::Error)
-    }
-}
-
-impl Display for Masked<'_> {
-    /// Display representation of a masked string is the masked string
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(&self.value()).map_err(|_| fmt::Error)
-    }
-}
-
-impl<'a> From<&'a Masked<'a>> for Cow<'a, str> {
-    fn from(masked: &'a Masked) -> Cow<'a, str> {
-        masked.value()
-    }
-}
-
-impl<'a> From<Masked<'a>> for Cow<'a, str> {
-    fn from(masked: Masked<'a>) -> Cow<'a, str> {
-        masked.value()
-    }
-}
-
-impl<'a> From<&'a Masked<'_>> for Text<'a> {
-    fn from(masked: &'a Masked) -> Text<'a> {
-        Text::raw(masked.value())
-    }
-}
-
-impl<'a> From<Masked<'a>> for Text<'a> {
-    fn from(masked: Masked<'a>) -> Text<'a> {
-        Text::raw(masked.value())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::borrow::Borrow;
-
-    use super::*;
-    use crate::text::Line;
-
-    #[test]
-    fn test_masked_value() {
-        let masked = Masked::new("12345", 'x');
-        assert_eq!(masked.value(), "xxxxx");
-    }
-
-    #[test]
-    fn test_masked_debug() {
-        let masked = Masked::new("12345", 'x');
-        assert_eq!(format!("{masked:?}"), "12345");
-    }
-
-    #[test]
-    fn test_masked_display() {
-        let masked = Masked::new("12345", 'x');
-        assert_eq!(format!("{masked}"), "xxxxx");
-    }
-
-    #[test]
-    fn test_masked_conversions() {
-        let masked = Masked::new("12345", 'x');
-
-        let text: Text = masked.borrow().into();
-        assert_eq!(text.lines, vec![Line::from("xxxxx")]);
-
-        let text: Text = masked.to_owned().into();
-        assert_eq!(text.lines, vec![Line::from("xxxxx")]);
-
-        let cow: Cow<str> = masked.borrow().into();
-        assert_eq!(cow, "xxxxx");
-
-        let cow: Cow<str> = masked.to_owned().into();
-        assert_eq!(cow, "xxxxx");
-    }
-}
--- a/src/text/spans.rs
+++ b/src/text/spans.rs
@@ -1,225 +0,0 @@
-#![allow(deprecated)]
-
-use super::{Span, Style};
-use crate::{layout::Alignment, text::Line};
-
-/// A string composed of clusters of graphemes, each with their own style.
-///
-/// `Spans` has been deprecated in favor of `Line`, and will be removed in the
-/// future. All methods that accept Spans have been replaced with methods that
-/// accept Into<Line<'a>> (which is implemented on `Spans`) to allow users of
-/// this crate to gradually transition to Line.
-#[derive(Debug, Clone, PartialEq, Default, Eq)]
-#[deprecated(note = "Use `ratatui::text::Line` instead")]
-pub struct Spans<'a>(pub Vec<Span<'a>>);
-
-impl<'a> Spans<'a> {
-    /// Returns the width of the underlying string.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use ratatui::text::{Span, Spans};
-    /// # use ratatui::style::{Color, Style};
-    /// let spans = Spans::from(vec![
-    ///     Span::styled("My", Style::default().fg(Color::Yellow)),
-    ///     Span::raw(" text"),
-    /// ]);
-    /// assert_eq!(7, spans.width());
-    /// ```
-    pub fn width(&self) -> usize {
-        self.0.iter().map(Span::width).sum()
-    }
-
-    /// Patches the style of each Span in an existing Spans, adding modifiers from the given style.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use ratatui::text::{Span, Spans};
-    /// # use ratatui::style::{Color, Style, Modifier};
-    /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
-    /// let mut raw_spans = Spans::from(vec![
-    ///     Span::raw("My"),
-    ///     Span::raw(" text"),
-    /// ]);
-    /// let mut styled_spans = Spans::from(vec![
-    ///     Span::styled("My", style),
-    ///     Span::styled(" text", style),
-    /// ]);
-    ///
-    /// assert_ne!(raw_spans, styled_spans);
-    ///
-    /// raw_spans.patch_style(style);
-    /// assert_eq!(raw_spans, styled_spans);
-    /// ```
-    pub fn patch_style(&mut self, style: Style) {
-        for span in &mut self.0 {
-            span.patch_style(style);
-        }
-    }
-
-    /// Resets the style of each Span in the Spans.
-    /// Equivalent to calling `patch_style(Style::reset())`.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use ratatui::text::{Span, Spans};
-    /// # use ratatui::style::{Color, Style, Modifier};
-    /// let mut spans = Spans::from(vec![
-    ///     Span::styled("My", Style::default().fg(Color::Yellow)),
-    ///     Span::styled(" text", Style::default().add_modifier(Modifier::BOLD)),
-    /// ]);
-    ///
-    /// spans.reset_style();
-    /// assert_eq!(Style::reset(), spans.0[0].style);
-    /// assert_eq!(Style::reset(), spans.0[1].style);
-    /// ```
-    pub fn reset_style(&mut self) {
-        for span in &mut self.0 {
-            span.reset_style();
-        }
-    }
-
-    /// Sets the target alignment for this line of text.
-    /// Defaults to: [`None`], meaning the alignment is determined by the rendering widget.
-    ///
-    /// ## Examples
-    ///
-    /// ```rust
-    /// # use std::borrow::Cow;
-    /// # use ratatui::layout::Alignment;
-    /// # use ratatui::text::{Span, Spans};
-    /// # use ratatui::style::{Color, Style, Modifier};
-    /// let mut line = Spans::from("Hi, what's up?").alignment(Alignment::Right);
-    /// assert_eq!(Some(Alignment::Right), line.alignment)
-    /// ```
-    pub fn alignment(self, alignment: Alignment) -> Line<'a> {
-        let line = Line::from(self);
-        line.alignment(alignment)
-    }
-}
-
-impl<'a> From<String> for Spans<'a> {
-    fn from(s: String) -> Spans<'a> {
-        Spans(vec![Span::from(s)])
-    }
-}
-
-impl<'a> From<&'a str> for Spans<'a> {
-    fn from(s: &'a str) -> Spans<'a> {
-        Spans(vec![Span::from(s)])
-    }
-}
-
-impl<'a> From<Vec<Span<'a>>> for Spans<'a> {
-    fn from(spans: Vec<Span<'a>>) -> Spans<'a> {
-        Spans(spans)
-    }
-}
-
-impl<'a> From<Span<'a>> for Spans<'a> {
-    fn from(span: Span<'a>) -> Spans<'a> {
-        Spans(vec![span])
-    }
-}
-
-impl<'a> From<Spans<'a>> for String {
-    fn from(line: Spans<'a>) -> String {
-        line.0.iter().fold(String::new(), |mut acc, s| {
-            acc.push_str(s.content.as_ref());
-            acc
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{
-        style::{Color, Modifier, Style},
-        text::{Span, Spans},
-    };
-
-    #[test]
-    fn test_width() {
-        let spans = Spans::from(vec![
-            Span::styled("My", Style::default().fg(Color::Yellow)),
-            Span::raw(" text"),
-        ]);
-        assert_eq!(7, spans.width());
-
-        let empty_spans = Spans::default();
-        assert_eq!(0, empty_spans.width());
-    }
-
-    #[test]
-    fn test_patch_style() {
-        let style = Style::default()
-            .fg(Color::Yellow)
-            .add_modifier(Modifier::ITALIC);
-        let mut raw_spans = Spans::from(vec![Span::raw("My"), Span::raw(" text")]);
-        let styled_spans = Spans::from(vec![
-            Span::styled("My", style),
-            Span::styled(" text", style),
-        ]);
-
-        assert_ne!(raw_spans, styled_spans);
-
-        raw_spans.patch_style(style);
-        assert_eq!(raw_spans, styled_spans);
-    }
-
-    #[test]
-    fn test_reset_style() {
-        let mut spans = Spans::from(vec![
-            Span::styled("My", Style::default().fg(Color::Yellow)),
-            Span::styled(" text", Style::default().add_modifier(Modifier::BOLD)),
-        ]);
-
-        spans.reset_style();
-        assert_eq!(Style::reset(), spans.0[0].style);
-        assert_eq!(Style::reset(), spans.0[1].style);
-    }
-
-    #[test]
-    fn test_from_string() {
-        let s = String::from("Hello, world!");
-        let spans = Spans::from(s);
-        assert_eq!(vec![Span::from("Hello, world!")], spans.0);
-    }
-
-    #[test]
-    fn test_from_str() {
-        let s = "Hello, world!";
-        let spans = Spans::from(s);
-        assert_eq!(vec![Span::from("Hello, world!")], spans.0);
-    }
-
-    #[test]
-    fn test_from_vec() {
-        let spans_vec = vec![
-            Span::styled("Hello,", Style::default().fg(Color::Red)),
-            Span::styled(" world!", Style::default().fg(Color::Green)),
-        ];
-        let spans = Spans::from(spans_vec.clone());
-        assert_eq!(spans_vec, spans.0);
-    }
-
-    #[test]
-    fn test_from_span() {
-        let span = Span::styled("Hello, world!", Style::default().fg(Color::Yellow));
-        let spans = Spans::from(span.clone());
-        assert_eq!(vec![span], spans.0);
-    }
-
-    #[test]
-    fn test_into_string() {
-        let spans = Spans::from(vec![
-            Span::styled("Hello,", Style::default().fg(Color::Red)),
-            Span::styled(" world!", Style::default().fg(Color::Green)),
-        ]);
-        let s: String = spans.into();
-        assert_eq!("Hello, world!", s);
-    }
-}
--- a/src/title.rs
+++ b/src/title.rs
@@ -1,57 +0,0 @@
-use crate::{layout::Alignment, text::Line};
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Title<'a> {
-    pub content: Line<'a>,
-    /// Defaults to Left if unset
-    pub alignment: Option<Alignment>,
-
-    /// Defaults to Top if unset
-    pub position: Option<Position>,
-}
-
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum Position {
-    #[default]
-    Top,
-    Bottom,
-}
-
-impl<'a> Title<'a> {
-    pub fn content<T>(mut self, content: T) -> Title<'a>
-    where
-        T: Into<Line<'a>>,
-    {
-        self.content = content.into();
-        self
-    }
-
-    pub fn alignment(mut self, alignment: Alignment) -> Title<'a> {
-        self.alignment = Some(alignment);
-        self
-    }
-
-    pub fn position(mut self, position: Position) -> Title<'a> {
-        self.position = Some(position);
-        self
-    }
-}
-
-impl<'a, T> From<T> for Title<'a>
-where
-    T: Into<Line<'a>>,
-{
-    fn from(value: T) -> Self {
-        Self::default().content(value.into())
-    }
-}
-
-impl<'a> Default for Title<'a> {
-    fn default() -> Self {
-        Self {
-            content: Line::from(""),
-            alignment: Some(Alignment::Left),
-            position: Some(Position::Top),
-        }
-    }
-}
--- a/src/widgets/barchart.rs
+++ b/src/widgets/barchart.rs
@@ -1,7 +1,3 @@
-use std::cmp::min;
-
-use unicode_width::UnicodeWidthStr;
-
 use crate::{
    buffer::Buffer,
    layout::Rect,
@@ -9,14 +5,16 @@ use crate::{
    symbols,
    widgets::{Block, Widget},
 };
+use std::cmp::min;
+use unicode_width::UnicodeWidthStr;

 /// Display multiple bars in a single widgets
 ///
 /// # Examples
 ///
 /// ```
-/// # use ratatui::widgets::{Block, Borders, BarChart};
-/// # use ratatui::style::{Style, Color, Modifier};
+/// # use tui::widgets::{Block, Borders, BarChart};
+/// # use tui::style::{Style, Color, Modifier};
 /// BarChart::default()
 ///     .block(Block::default().title("BarChart").borders(Borders::ALL))
 ///     .bar_width(3)
@@ -65,9 +63,9 @@ impl<'a> Default for BarChart<'a> {
            bar_width: 1,
            bar_gap: 1,
            bar_set: symbols::bar::NINE_LEVELS,
-            value_style: Style::default(),
-            label_style: Style::default(),
-            style: Style::default(),
+            value_style: Default::default(),
+            label_style: Default::default(),
+            style: Default::default(),
        }
    }
 }
@@ -77,7 +75,7 @@ impl<'a> BarChart<'a> {
        self.data = data;
        self.values = Vec::with_capacity(self.data.len());
        for &(_, v) in self.data {
-            self.values.push(format!("{v}"));
+            self.values.push(format!("{}", v));
        }
        self
    }
--- a/src/widgets/block.rs
+++ b/src/widgets/block.rs
@@ -1,16 +1,13 @@
-#[path = "../title.rs"]
-pub mod title;
-
-use self::title::{Position, Title};
 use crate::{
    buffer::Buffer,
    layout::{Alignment, Rect},
-    style::{Style, Styled},
+    style::Style,
    symbols::line,
+    text::{Span, Spans},
    widgets::{Borders, Widget},
 };

-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum BorderType {
    Plain,
    Rounded,
@@ -19,7 +16,7 @@ pub enum BorderType {
 }

 impl BorderType {
-    pub const fn line_symbols(border_type: BorderType) -> line::Set {
+    pub fn line_symbols(border_type: BorderType) -> line::Set {
        match border_type {
            BorderType::Plain => line::NORMAL,
            BorderType::Rounded => line::ROUNDED,
@@ -29,69 +26,14 @@ impl BorderType {
    }
 }

-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct Padding {
-    pub left: u16,
-    pub right: u16,
-    pub top: u16,
-    pub bottom: u16,
-}
-
-impl Padding {
-    pub const fn new(left: u16, right: u16, top: u16, bottom: u16) -> Self {
-        Padding {
-            left,
-            right,
-            top,
-            bottom,
-        }
-    }
-
-    pub const fn zero() -> Self {
-        Padding {
-            left: 0,
-            right: 0,
-            top: 0,
-            bottom: 0,
-        }
-    }
-
-    pub const fn horizontal(value: u16) -> Self {
-        Padding {
-            left: value,
-            right: value,
-            top: 0,
-            bottom: 0,
-        }
-    }
-
-    pub const fn vertical(value: u16) -> Self {
-        Padding {
-            left: 0,
-            right: 0,
-            top: value,
-            bottom: value,
-        }
-    }
-
-    pub const fn uniform(value: u16) -> Self {
-        Padding {
-            left: value,
-            right: value,
-            top: value,
-            bottom: value,
-        }
-    }
-}
-
 /// Base widget to be used with all upper level ones. It may be used to display a box border around
 /// the widget and/or add a title.
 ///
 /// # Examples
 ///
 /// ```
-/// # use ratatui::widgets::{Block, BorderType, Borders};
-/// # use ratatui::style::{Style, Color};
+/// # use tui::widgets::{Block, BorderType, Borders};
+/// # use tui::style::{Style, Color};
 /// Block::default()
 ///     .title("Block")
 ///     .borders(Borders::LEFT | Borders::RIGHT)
@@ -99,204 +41,91 @@ impl Padding {
 ///     .border_type(BorderType::Rounded)
 ///     .style(Style::default().bg(Color::Black));
 /// ```
-///
-/// You may also use multiple titles like in the following:
-/// ```
-/// # use ratatui::widgets::{Block, BorderType, Borders, block::title::{Position, Title}};
-/// # use ratatui::style::{Style, Color};
-/// Block::default()
-///     .title("Title 1")
-///     .title(Title::from("Title 2").position(Position::Bottom))
-///     .borders(Borders::LEFT | Borders::RIGHT)
-///     .border_style(Style::default().fg(Color::White))
-///     .border_type(BorderType::Rounded)
-///     .style(Style::default().bg(Color::Black));
-/// ```
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Block<'a> {
-    /// List of titles
-    titles: Vec<Title<'a>>,
-    /// The style to be patched to all titles of the block
-    titles_style: Style,
-    /// The default alignment of the titles that don't have one
-    titles_alignment: Alignment,
-    /// The default position of the titles that don't have one
-    titles_position: Position,
-
+    /// Optional title place on the upper left of the block
+    title: Option<Spans<'a>>,
+    /// Title alignment. The default is top left of the block, but one can choose to place
+    /// title in the top middle, or top right of the block
+    title_alignment: Alignment,
    /// Visible borders
    borders: Borders,
    /// Border style
    border_style: Style,
-    /// Type of the border. The default is plain lines but one can choose to have rounded or
-    /// doubled lines instead.
+    /// Type of the border. The default is plain lines but one can choose to have rounded corners
+    /// or doubled lines instead.
    border_type: BorderType,
-
    /// Widget style
    style: Style,
-    /// Block padding
-    padding: Padding,
 }

 impl<'a> Default for Block<'a> {
    fn default() -> Block<'a> {
-        Block::new()
+        Block {
+            title: None,
+            title_alignment: Alignment::Left,
+            borders: Borders::NONE,
+            border_style: Default::default(),
+            border_type: BorderType::Plain,
+            style: Default::default(),
+        }
    }
 }

 impl<'a> Block<'a> {
-    pub const fn new() -> Self {
-        Self {
-            titles: Vec::new(),
-            titles_style: Style::new(),
-            titles_alignment: Alignment::Left,
-            titles_position: Position::Top,
-            borders: Borders::NONE,
-            border_style: Style::new(),
-            border_type: BorderType::Plain,
-            style: Style::new(),
-            padding: Padding::zero(),
-        }
-    }
-    /// # Example
-    /// ```
-    /// # use ratatui::widgets::{Block, block::title::Title};
-    /// # use ratatui::layout::Alignment;
-    /// Block::default()
-    ///    .title("Title") // By default in the top right corner
-    ///    .title(Title::from("Left").alignment(Alignment::Left))
-    ///    .title(
-    ///        Title::from("Center")
-    ///            .alignment(Alignment::Center),
-    ///    );
-    /// ```
-    /// Adds a title to the block.
-    ///
-    /// The `title` function allows you to add a title to the block. You can call this function
-    /// multiple times to add multiple titles.
-    ///
-    /// Each title will be rendered with a single space separating titles that are in the same
-    /// position or alignment. When both centered and non-centered titles are rendered, the centered
-    /// space is calculated based on the full width of the block, rather than the leftover width.
-    ///
-    /// You can provide various types as the title, including strings, string slices, borrowed
-    /// strings (`Cow<str>`), spans, or vectors of spans (`Vec<Span>`).
-    ///
-    /// By default, the titles will avoid being rendered in the corners of the block but will align
-    /// against the left or right edge of the block if there is no border on that edge.
-    ///
-    /// Note: If the block is too small and multiple titles overlap, the border might get cut off at
-    /// a corner.
    pub fn title<T>(mut self, title: T) -> Block<'a>
    where
-        T: Into<Title<'a>>,
+        T: Into<Spans<'a>>,
    {
-        self.titles.push(title.into());
+        self.title = Some(title.into());
        self
    }

-    /// Applies the style to all titles. If a title already has a style, it will add on top of it.
-    pub const fn title_style(mut self, style: Style) -> Block<'a> {
-        self.titles_style = style;
+    #[deprecated(
+        since = "0.10.0",
+        note = "You should use styling capabilities of `text::Spans` given as argument of the `title` method to apply styling to the title."
+    )]
+    pub fn title_style(mut self, style: Style) -> Block<'a> {
+        if let Some(t) = self.title {
+            let title = String::from(t);
+            self.title = Some(Spans::from(Span::styled(title, style)));
+        }
        self
    }

-    /// Aligns all elements that don't have an alignment
-    /// # Example
-    /// This example aligns all titles in the center except "right" title
-    /// ```
-    /// # use ratatui::widgets::{Block, block::title::Title};
-    /// # use ratatui::layout::Alignment;
-    /// Block::default()
-    ///   // This title won't be aligned in the center
-    ///   .title(Title::from("right").alignment(Alignment::Right))
-    ///   .title("foo")
-    ///   .title("bar")
-    ///   .title_alignment(Alignment::Center);
-    /// ```
-    pub const fn title_alignment(mut self, alignment: Alignment) -> Block<'a> {
-        self.titles_alignment = alignment;
+    pub fn title_alignment(mut self, alignment: Alignment) -> Block<'a> {
+        self.title_alignment = alignment;
        self
    }

-    #[deprecated(since = "0.22.0", note = "You should use a `title_position` instead.")]
-    /// This method just calls `title_position` with Position::Bottom
-    pub fn title_on_bottom(self) -> Block<'a> {
-        self.title_position(Position::Bottom)
-    }
-
-    /// Positions all titles that don't have a position
-    /// # Example
-    /// This example position all titles on the bottom except "top" title
-    /// ```
-    /// # use ratatui::widgets::{Block, BorderType, Borders, block::title::{Position, Title}};
-    /// Block::default()
-    ///   // This title won't be aligned in the center
-    ///   .title(Title::from("top").position(Position::Top))
-    ///   .title("foo")
-    ///   .title("bar")
-    ///   .title_position(Position::Bottom);
-    /// ```
-    pub const fn title_position(mut self, position: Position) -> Block<'a> {
-        self.titles_position = position;
-        self
-    }
-
-    pub const fn border_style(mut self, style: Style) -> Block<'a> {
+    pub fn border_style(mut self, style: Style) -> Block<'a> {
        self.border_style = style;
        self
    }

-    pub const fn style(mut self, style: Style) -> Block<'a> {
+    pub fn style(mut self, style: Style) -> Block<'a> {
        self.style = style;
        self
    }

-    pub const fn borders(mut self, flag: Borders) -> Block<'a> {
+    pub fn borders(mut self, flag: Borders) -> Block<'a> {
        self.borders = flag;
        self
    }

-    pub const fn border_type(mut self, border_type: BorderType) -> Block<'a> {
+    pub fn border_type(mut self, border_type: BorderType) -> Block<'a> {
        self.border_type = border_type;
        self
    }

    /// Compute the inner area of a block based on its border visibility rules.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// // Draw a block nested within another block
-    /// use ratatui::{backend::TestBackend, buffer::Buffer, terminal::Terminal, widgets::{Block, Borders}};
-    /// let backend = TestBackend::new(15, 5);
-    /// let mut terminal = Terminal::new(backend).unwrap();
-    /// let outer_block = Block::default()
-    ///     .title("Outer Block")
-    ///     .borders(Borders::ALL);
-    /// let inner_block = Block::default()
-    ///     .title("Inner Block")
-    ///     .borders(Borders::ALL);
-    /// terminal.draw(|f| {
-    ///     let inner_area = outer_block.inner(f.size());
-    ///     f.render_widget(outer_block, f.size());
-    ///     f.render_widget(inner_block, inner_area);
-    /// });
-    /// let expected = Buffer::with_lines(vec![
-    ///     "┌Outer Block──┐",
-    ///     "│┌Inner Block┐│",
-    ///     "││           ││",
-    ///     "│└───────────┘│",
-    ///     "└─────────────┘",
-    /// ]);
-    /// terminal.backend().assert_buffer(&expected);
-    /// ```
    pub fn inner(&self, area: Rect) -> Rect {
        let mut inner = area;
        if self.borders.intersects(Borders::LEFT) {
            inner.x = inner.x.saturating_add(1).min(inner.right());
            inner.width = inner.width.saturating_sub(1);
        }
-        if self.borders.intersects(Borders::TOP) || !self.titles.is_empty() {
+        if self.borders.intersects(Borders::TOP) || self.title.is_some() {
            inner.y = inner.y.saturating_add(1).min(inner.bottom());
            inner.height = inner.height.saturating_sub(1);
        }
@@ -306,26 +135,15 @@ impl<'a> Block<'a> {
        if self.borders.intersects(Borders::BOTTOM) {
            inner.height = inner.height.saturating_sub(1);
        }
-
-        inner.x = inner.x.saturating_add(self.padding.left);
-        inner.y = inner.y.saturating_add(self.padding.top);
-
-        inner.width = inner
-            .width
-            .saturating_sub(self.padding.left + self.padding.right);
-        inner.height = inner
-            .height
-            .saturating_sub(self.padding.top + self.padding.bottom);
-
        inner
    }
+}

-    pub const fn padding(mut self, padding: Padding) -> Block<'a> {
-        self.padding = padding;
-        self
-    }
-
-    fn render_borders(&self, area: Rect, buf: &mut Buffer) {
+impl<'a> Widget for Block<'a> {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        if area.area() == 0 {
+            return;
+        }
        buf.set_style(area, self.style);
        let symbols = BorderType::line_symbols(self.border_type);

@@ -382,133 +200,41 @@ impl<'a> Block<'a> {
                .set_symbol(symbols.top_left)
                .set_style(self.border_style);
        }
-    }

-    /* Titles Rendering */
-    fn get_title_y(&self, position: Position, area: Rect) -> u16 {
-        match position {
-            Position::Bottom => area.bottom() - 1,
-            Position::Top => area.top(),
+        // Title
+        if let Some(title) = self.title {
+            let left_border_dx = if self.borders.intersects(Borders::LEFT) {
+                1
+            } else {
+                0
+            };
+
+            let right_border_dx = if self.borders.intersects(Borders::RIGHT) {
+                1
+            } else {
+                0
+            };
+
+            let title_area_width = area
+                .width
+                .saturating_sub(left_border_dx)
+                .saturating_sub(right_border_dx);
+
+            let title_dx = match self.title_alignment {
+                Alignment::Left => left_border_dx,
+                Alignment::Center => area.width.saturating_sub(title.width() as u16) / 2,
+                Alignment::Right => area
+                    .width
+                    .saturating_sub(title.width() as u16)
+                    .saturating_sub(right_border_dx),
+            };
+
+            let title_x = area.left() + title_dx;
+            let title_y = area.top();
+
+            buf.set_spans(title_x, title_y, &title, title_area_width);
        }
    }
-
-    fn title_filter(&self, title: &Title, alignment: Alignment, position: Position) -> bool {
-        title.alignment.unwrap_or(self.titles_alignment) == alignment
-            && title.position.unwrap_or(self.titles_position) == position
-    }
-
-    fn calculate_title_area_offsets(&self, area: Rect) -> (u16, u16, u16) {
-        let left_border_dx = u16::from(self.borders.intersects(Borders::LEFT));
-        let right_border_dx = u16::from(self.borders.intersects(Borders::RIGHT));
-
-        let title_area_width = area
-            .width
-            .saturating_sub(left_border_dx)
-            .saturating_sub(right_border_dx);
-
-        (left_border_dx, right_border_dx, title_area_width)
-    }
-
-    fn render_left_titles(&self, position: Position, area: Rect, buf: &mut Buffer) {
-        let (left_border_dx, _, title_area_width) = self.calculate_title_area_offsets(area);
-
-        let mut current_offset = left_border_dx;
-        self.titles
-            .iter()
-            .filter(|title| self.title_filter(title, Alignment::Left, position))
-            .for_each(|title| {
-                let title_x = current_offset;
-                current_offset += title.content.width() as u16 + 1;
-
-                buf.set_line(
-                    title_x + area.left(),
-                    self.get_title_y(position, area),
-                    &title.content,
-                    title_area_width,
-                );
-            });
-    }
-
-    fn render_center_titles(&self, position: Position, area: Rect, buf: &mut Buffer) {
-        let (_, _, title_area_width) = self.calculate_title_area_offsets(area);
-
-        let titles = self
-            .titles
-            .iter()
-            .filter(|title| self.title_filter(title, Alignment::Center, position));
-
-        let titles_sum = titles
-            .clone()
-            .fold(-1, |acc, f| acc + f.content.width() as i16 + 1); // First element isn't spaced
-
-        let mut current_offset = area.width.saturating_sub(titles_sum as u16) / 2;
-        titles.for_each(|title| {
-            let title_x = current_offset;
-            current_offset += title.content.width() as u16 + 1;
-
-            buf.set_line(
-                title_x + area.left(),
-                self.get_title_y(position, area),
-                &title.content,
-                title_area_width,
-            );
-        });
-    }
-
-    fn render_right_titles(&self, position: Position, area: Rect, buf: &mut Buffer) {
-        let (_, right_border_dx, title_area_width) = self.calculate_title_area_offsets(area);
-
-        let mut current_offset = right_border_dx;
-        self.titles
-            .iter()
-            .filter(|title| self.title_filter(title, Alignment::Right, position))
-            .rev() // so that the titles appear in the order they have been set
-            .for_each(|title| {
-                current_offset += title.content.width() as u16 + 1;
-                let title_x = current_offset - 1; // First element isn't spaced
-
-                buf.set_line(
-                    area.width.saturating_sub(title_x) + area.left(),
-                    self.get_title_y(position, area),
-                    &title.content,
-                    title_area_width,
-                );
-            });
-    }
-
-    fn render_title_position(&self, position: Position, area: Rect, buf: &mut Buffer) {
-        // Note: the order in which these functions are called define the overlapping behavior
-        self.render_right_titles(position, area, buf);
-        self.render_center_titles(position, area, buf);
-        self.render_left_titles(position, area, buf);
-    }
-
-    fn render_titles(&self, area: Rect, buf: &mut Buffer) {
-        self.render_title_position(Position::Top, area, buf);
-        self.render_title_position(Position::Bottom, area, buf);
-    }
-}
-
-impl<'a> Widget for Block<'a> {
-    fn render(self, area: Rect, buf: &mut Buffer) {
-        if area.area() == 0 {
-            return;
-        }
-        self.render_borders(area, buf);
-        self.render_titles(area, buf);
-    }
-}
-
-impl<'a> Styled for Block<'a> {
-    type Item = Block<'a>;
-
-    fn style(&self) -> Style {
-        self.style
-    }
-
-    fn set_style(self, style: Style) -> Self::Item {
-        self.style(style)
-    }
 }

 #[cfg(test)]
@@ -811,7 +537,8 @@ mod tests {
        );
        assert_eq!(
            Block::default()
-                .title(Title::from("Test").alignment(Alignment::Center))
+                .title("Test")
+                .title_alignment(Alignment::Center)
                .inner(Rect {
                    x: 0,
                    y: 0,
@@ -827,7 +554,8 @@ mod tests {
        );
        assert_eq!(
            Block::default()
-                .title(Title::from("Test").alignment(Alignment::Right))
+                .title("Test")
+                .title_alignment(Alignment::Right)
                .inner(Rect {
                    x: 0,
                    y: 0,
@@ -842,34 +570,4 @@ mod tests {
            },
        );
    }
-
-    #[test]
-    fn border_type_can_be_const() {
-        const _PLAIN: line::Set = BorderType::line_symbols(BorderType::Plain);
-    }
-
-    #[test]
-    fn padding_can_be_const() {
-        const PADDING: Padding = Padding::new(1, 1, 1, 1);
-        const UNI_PADDING: Padding = Padding::uniform(1);
-        assert_eq!(PADDING, UNI_PADDING);
-
-        const _NO_PADDING: Padding = Padding::zero();
-        const _HORIZONTAL: Padding = Padding::horizontal(1);
-        const _VERTICAL: Padding = Padding::vertical(1);
-    }
-
-    #[test]
-    fn block_can_be_const() {
-        const _DEFAULT_STYLE: Style = Style::new();
-        const _DEFAULT_PADDING: Padding = Padding::uniform(1);
-        const _DEFAULT_BLOCK: Block = Block::new()
-            .title_style(_DEFAULT_STYLE)
-            .title_alignment(Alignment::Left)
-            .title_position(Position::Top)
-            .borders(Borders::ALL)
-            .border_style(_DEFAULT_STYLE)
-            .style(_DEFAULT_STYLE)
-            .padding(_DEFAULT_PADDING);
-    }
 }
--- a/src/widgets/calendar.rs
+++ b/src/widgets/calendar.rs
@@ -1,246 +0,0 @@
-//! A simple calendar widget. `(feature: widget-calendar)`
-//!
-//!
-//!
-//! The [`Monthly`] widget will display a calendar for the monh provided in `display_date`. Days are
-//! styled using the default style unless:
-//! * `show_surrounding` is set, then days not in the `display_date` month will use that style.
-//! * a style is returned by the [`DateStyler`] for the day
-//!
-//! [`Monthly`] has several controls for what should be displayed
-use std::collections::HashMap;
-
-use time::{Date, Duration, OffsetDateTime};
-
-use crate::{
-    buffer::Buffer,
-    layout::Rect,
-    style::Style,
-    text::Span,
-    widgets::{Block, Widget},
-};
-
-/// Display a month calendar for the month containing `display_date`
-pub struct Monthly<'a, S: DateStyler> {
-    display_date: Date,
-    events: S,
-    show_surrounding: Option<Style>,
-    show_weekday: Option<Style>,
-    show_month: Option<Style>,
-    default_style: Style,
-    block: Option<Block<'a>>,
-}
-
-impl<'a, S: DateStyler> Monthly<'a, S> {
-    /// Construct a calendar for the `display_date` and highlight the `events`
-    pub fn new(display_date: Date, events: S) -> Self {
-        Self {
-            display_date,
-            events,
-            show_surrounding: None,
-            show_weekday: None,
-            show_month: None,
-            default_style: Style::default(),
-            block: None,
-        }
-    }
-
-    /// Fill the calendar slots for days not in the current month also, this causes each line to be
-    /// completely filled. If there is an event style for a date, this style will be patched with
-    /// the event's style
-    pub fn show_surrounding(mut self, style: Style) -> Self {
-        self.show_surrounding = Some(style);
-        self
-    }
-
-    /// Display a header containing weekday abbreviations
-    pub fn show_weekdays_header(mut self, style: Style) -> Self {
-        self.show_weekday = Some(style);
-        self
-    }
-
-    /// Display a header containing the month and year
-    pub fn show_month_header(mut self, style: Style) -> Self {
-        self.show_month = Some(style);
-        self
-    }
-
-    /// How to render otherwise unstyled dates
-    pub fn default_style(mut self, s: Style) -> Self {
-        self.default_style = s;
-        self
-    }
-
-    /// Render the calendar within a [Block](crate::widgets::Block)
-    pub fn block(mut self, b: Block<'a>) -> Self {
-        self.block = Some(b);
-        self
-    }
-
-    /// Return a style with only the background from the default style
-    fn default_bg(&self) -> Style {
-        match self.default_style.bg {
-            None => Style::default(),
-            Some(c) => Style::default().bg(c),
-        }
-    }
-
-    /// All logic to style a date goes here.
-    fn format_date(&self, date: Date) -> Span {
-        if date.month() != self.display_date.month() {
-            match self.show_surrounding {
-                None => Span::styled("  ", self.default_bg()),
-                Some(s) => {
-                    let style = self
-                        .default_style
-                        .patch(s)
-                        .patch(self.events.get_style(date));
-                    Span::styled(format!("{:2?}", date.day()), style)
-                }
-            }
-        } else {
-            Span::styled(
-                format!("{:2?}", date.day()),
-                self.default_style.patch(self.events.get_style(date)),
-            )
-        }
-    }
-}
-
-impl<'a, S: DateStyler> Widget for Monthly<'a, S> {
-    fn render(mut self, area: Rect, buf: &mut Buffer) {
-        // Block is used for borders and such
-        // Draw that first, and use the blank area inside the block for our own purposes
-        let mut area = match self.block.take() {
-            None => area,
-            Some(b) => {
-                let inner = b.inner(area);
-                b.render(area, buf);
-                inner
-            }
-        };
-
-        // Draw the month name and year
-        if let Some(style) = self.show_month {
-            let line = Span::styled(
-                format!("{} {}", self.display_date.month(), self.display_date.year()),
-                style,
-            );
-            // cal is 21 cells wide, so hard code the 11
-            let x_off = 11_u16.saturating_sub(line.width() as u16 / 2);
-            buf.set_line(area.x + x_off, area.y, &line.into(), area.width);
-            area.y += 1
-        }
-
-        // Draw days of week
-        if let Some(style) = self.show_weekday {
-            let days = String::from(" Su Mo Tu We Th Fr Sa");
-            buf.set_string(area.x, area.y, days, style);
-            area.y += 1;
-        }
-
-        // Set the start of the calendar to the Sunday before the 1st (or the sunday of the first)
-        let first_of_month = self.display_date.replace_day(1).unwrap();
-        let offset = Duration::days(first_of_month.weekday().number_days_from_sunday().into());
-        let mut curr_day = first_of_month - offset;
-
-        // go through all the weeks containing a day in the target month.
-        while curr_day.month() as u8 != self.display_date.month().next() as u8 {
-            let mut spans = Vec::with_capacity(14);
-            for i in 0..7 {
-                // Draw the gutter. Do it here so we can avoid worrying about
-                // styling the ' ' in the format_date method
-                if i == 0 {
-                    spans.push(Span::styled(" ", Style::default()));
-                } else {
-                    spans.push(Span::styled(" ", self.default_bg()));
-                }
-                spans.push(self.format_date(curr_day));
-                curr_day += Duration::DAY;
-            }
-            buf.set_line(area.x, area.y, &spans.into(), area.width);
-            area.y += 1;
-        }
-    }
-}
-
-/// Provides a method for styling a given date. [Monthly] is generic on this trait, so any type
-/// that implements this trait can be used.
-pub trait DateStyler {
-    /// Given a date, return a style for that date
-    fn get_style(&self, date: Date) -> Style;
-}
-
-/// A simple `DateStyler` based on a [`HashMap`]
-pub struct CalendarEventStore(pub HashMap<Date, Style>);
-
-impl CalendarEventStore {
-    /// Construct a store that has the current date styled.
-    pub fn today(style: Style) -> Self {
-        let mut res = Self::default();
-        res.add(OffsetDateTime::now_local().unwrap().date(), style);
-        res
-    }
-
-    /// Add a date and style to the store
-    pub fn add(&mut self, date: Date, style: Style) {
-        // to simplify style nonsense, last write wins
-        let _ = self.0.insert(date, style);
-    }
-
-    /// Helper for trait impls
-    fn lookup_style(&self, date: Date) -> Style {
-        self.0.get(&date).copied().unwrap_or_default()
-    }
-}
-
-impl DateStyler for CalendarEventStore {
-    fn get_style(&self, date: Date) -> Style {
-        self.lookup_style(date)
-    }
-}
-
-impl DateStyler for &CalendarEventStore {
-    fn get_style(&self, date: Date) -> Style {
-        self.lookup_style(date)
-    }
-}
-
-impl Default for CalendarEventStore {
-    fn default() -> Self {
-        Self(HashMap::with_capacity(4))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use time::Month;
-
-    use super::*;
-    use crate::style::Color;
-
-    #[test]
-    fn event_store() {
-        let a = (
-            Date::from_calendar_date(2023, Month::January, 1).unwrap(),
-            Style::default(),
-        );
-        let b = (
-            Date::from_calendar_date(2023, Month::January, 2).unwrap(),
-            Style::default().bg(Color::Red).fg(Color::Blue),
-        );
-        let mut s = CalendarEventStore::default();
-        s.add(b.0, b.1);
-
-        assert_eq!(
-            s.get_style(a.0),
-            a.1,
-            "Date not added to the styler should look up as Style::default()"
-        );
-        assert_eq!(
-            s.get_style(b.0),
-            b.1,
-            "Date added to styler should return the provided style"
-        );
-    }
-}
--- a/src/widgets/canvas/circle.rs
+++ b/src/widgets/canvas/circle.rs
@@ -1,66 +0,0 @@
-use crate::{
-    style::Color,
-    widgets::canvas::{Painter, Shape},
-};
-
-/// Shape to draw a circle with a given center and radius and with the given color
-#[derive(Debug, Clone)]
-pub struct Circle {
-    pub x: f64,
-    pub y: f64,
-    pub radius: f64,
-    pub color: Color,
-}
-
-impl Shape for Circle {
-    fn draw(&self, painter: &mut Painter<'_, '_>) {
-        for angle in 0..360 {
-            let radians = f64::from(angle).to_radians();
-            let circle_x = self.radius.mul_add(radians.cos(), self.x);
-            let circle_y = self.radius.mul_add(radians.sin(), self.y);
-            if let Some((x, y)) = painter.get_point(circle_x, circle_y) {
-                painter.paint(x, y, self.color);
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{
-        buffer::Buffer,
-        layout::Rect,
-        style::Color,
-        symbols::Marker,
-        widgets::{
-            canvas::{Canvas, Circle},
-            Widget,
-        },
-    };
-
-    #[test]
-    fn test_it_draws_a_circle() {
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 10, 5));
-        let canvas = Canvas::default()
-            .paint(|ctx| {
-                ctx.draw(&Circle {
-                    x: 5.0,
-                    y: 2.0,
-                    radius: 5.0,
-                    color: Color::Reset,
-                });
-            })
-            .marker(Marker::Braille)
-            .x_bounds([-10.0, 10.0])
-            .y_bounds([-10.0, 10.0]);
-        canvas.render(buffer.area, &mut buffer);
-        let expected = Buffer::with_lines(vec![
-            "     ⢀⣠⢤⣀ ",
-            "    ⢰⠋  ⠈⣇",
-            "    ⠘⣆⡀ ⣠⠇",
-            "      ⠉⠉⠁ ",
-            "          ",
-        ]);
-        assert_eq!(buffer, expected);
-    }
-}
--- a/src/widgets/canvas/line.rs
+++ b/src/widgets/canvas/line.rs
@@ -15,11 +15,13 @@ pub struct Line {

 impl Shape for Line {
    fn draw(&self, painter: &mut Painter) {
-        let Some((x1, y1)) = painter.get_point(self.x1, self.y1) else {
-            return;
+        let (x1, y1) = match painter.get_point(self.x1, self.y1) {
+            Some(c) => c,
+            None => return,
        };
-        let Some((x2, y2)) = painter.get_point(self.x2, self.y2) else {
-            return;
+        let (x2, y2) = match painter.get_point(self.x2, self.y2) {
+            Some(c) => c,
+            None => return,
        };
        let (dx, x_range) = if x2 >= x1 {
            (x2 - x1, x1..=x2)
--- a/src/widgets/canvas/mod.rs
+++ b/src/widgets/canvas/mod.rs
@@ -1,27 +1,22 @@
-mod circle;
 mod line;
 mod map;
 mod points;
 mod rectangle;
 mod world;

-use std::fmt::Debug;
+pub use self::line::Line;
+pub use self::map::{Map, MapResolution};
+pub use self::points::Points;
+pub use self::rectangle::Rectangle;

-pub use self::{
-    circle::Circle,
-    line::Line,
-    map::{Map, MapResolution},
-    points::Points,
-    rectangle::Rectangle,
-};
 use crate::{
    buffer::Buffer,
    layout::Rect,
    style::{Color, Style},
    symbols,
-    text::Line as TextLine,
    widgets::{Block, Widget},
 };
+use std::fmt::Debug;

 /// Interface for all shapes that may be drawn on a Canvas widget.
 pub trait Shape {
@@ -31,9 +26,10 @@ pub trait Shape {
 /// Label to draw some text on the canvas
 #[derive(Debug, Clone)]
 pub struct Label<'a> {
-    x: f64,
-    y: f64,
-    line: TextLine<'a>,
+    pub x: f64,
+    pub y: f64,
+    pub text: &'a str,
+    pub color: Color,
 }

 #[derive(Debug, Clone)]
@@ -187,7 +183,7 @@ impl<'a, 'b> Painter<'a, 'b> {
    ///
    /// # Examples:
    /// ```
-    /// use ratatui::{symbols, widgets::canvas::{Painter, Context}};
+    /// use tui::{symbols, widgets::canvas::{Painter, Context}};
    ///
    /// let mut ctx = Context::new(2, 2, [1.0, 2.0], [0.0, 2.0], symbols::Marker::Braille);
    /// let mut painter = Painter::from(&mut ctx);
@@ -224,7 +220,7 @@ impl<'a, 'b> Painter<'a, 'b> {
    ///
    /// # Examples:
    /// ```
-    /// use ratatui::{style::Color, symbols, widgets::canvas::{Painter, Context}};
+    /// use tui::{style::Color, symbols, widgets::canvas::{Painter, Context}};
    ///
    /// let mut ctx = Context::new(1, 1, [0.0, 2.0], [0.0, 2.0], symbols::Marker::Braille);
    /// let mut painter = Painter::from(&mut ctx);
@@ -264,13 +260,9 @@ impl<'a> Context<'a> {
        y_bounds: [f64; 2],
        marker: symbols::Marker,
    ) -> Context<'a> {
-        let dot = symbols::DOT.chars().next().unwrap();
-        let block = symbols::block::FULL.chars().next().unwrap();
-        let bar = symbols::bar::HALF.chars().next().unwrap();
        let grid: Box<dyn Grid> = match marker {
-            symbols::Marker::Dot => Box::new(CharGrid::new(width, height, dot)),
-            symbols::Marker::Block => Box::new(CharGrid::new(width, height, block)),
-            symbols::Marker::Bar => Box::new(CharGrid::new(width, height, bar)),
+            symbols::Marker::Dot => Box::new(CharGrid::new(width, height, '•')),
+            symbols::Marker::Block => Box::new(CharGrid::new(width, height, '▄')),
            symbols::Marker::Braille => Box::new(BrailleGrid::new(width, height)),
        };
        Context {
@@ -301,21 +293,14 @@ impl<'a> Context<'a> {
    }

    /// Print a string on the canvas at the given position
-    pub fn print<T>(&mut self, x: f64, y: f64, line: T)
-    where
-        T: Into<TextLine<'a>>,
-    {
-        self.labels.push(Label {
-            x,
-            y,
-            line: line.into(),
-        });
+    pub fn print(&mut self, x: f64, y: f64, text: &'a str, color: Color) {
+        self.labels.push(Label { x, y, text, color });
    }

    /// Push the last layer if necessary
    fn finish(&mut self) {
        if self.dirty {
-            self.layer();
+            self.layer()
        }
    }
 }
@@ -325,10 +310,10 @@ impl<'a> Context<'a> {
 /// # Examples
 ///
 /// ```
-/// # use ratatui::widgets::{Block, Borders};
-/// # use ratatui::layout::Rect;
-/// # use ratatui::widgets::canvas::{Canvas, Shape, Line, Rectangle, Map, MapResolution};
-/// # use ratatui::style::Color;
+/// # use tui::widgets::{Block, Borders};
+/// # use tui::layout::Rect;
+/// # use tui::widgets::canvas::{Canvas, Shape, Line, Rectangle, Map, MapResolution};
+/// # use tui::style::Color;
 /// Canvas::default()
 ///     .block(Block::default().title("Canvas").borders(Borders::ALL))
 ///     .x_bounds([-180.0, 180.0])
@@ -392,18 +377,11 @@ where
        self
    }

-    /// Define the viewport of the canvas.
-    /// If you were to "zoom" to a certain part of the world you may want to choose different
-    /// bounds.
    pub fn x_bounds(mut self, bounds: [f64; 2]) -> Canvas<'a, F> {
        self.x_bounds = bounds;
        self
    }

-    /// Define the viewport of the canvas.
-    ///
-    /// If you were to "zoom" to a certain part of the world you may want to choose different
-    /// bounds.
    pub fn y_bounds(mut self, bounds: [f64; 2]) -> Canvas<'a, F> {
        self.y_bounds = bounds;
        self
@@ -427,8 +405,8 @@ where
    /// # Examples
    ///
    /// ```
-    /// # use ratatui::widgets::canvas::Canvas;
-    /// # use ratatui::symbols;
+    /// # use tui::widgets::canvas::Canvas;
+    /// # use tui::symbols;
    /// Canvas::default().marker(symbols::Marker::Braille).paint(|ctx| {});
    ///
    /// Canvas::default().marker(symbols::Marker::Dot).paint(|ctx| {});
@@ -455,12 +433,11 @@ where
            None => area,
        };

-        buf.set_style(canvas_area, Style::default().bg(self.background_color));
-
        let width = canvas_area.width as usize;

-        let Some(ref painter) = self.painter else {
-            return;
+        let painter = match self.painter {
+            Some(ref p) => p,
+            None => return,
        };

        // Create a blank context that match the size of the canvas
@@ -475,7 +452,7 @@ where
        painter(&mut ctx);
        ctx.finish();

-        // Retrieve painted points for each layer
+        // Retreive painted points for each layer
        for layer in ctx.layers {
            for (i, (ch, color)) in layer
                .string
@@ -487,12 +464,14 @@ where
                    let (x, y) = (i % width, i / width);
                    buf.get_mut(x as u16 + canvas_area.left(), y as u16 + canvas_area.top())
                        .set_char(ch)
-                        .set_fg(color);
+                        .set_fg(color)
+                        .set_bg(self.background_color);
                }
            }
        }

        // Finally draw the labels
+        let style = Style::default().bg(self.background_color);
        let left = self.x_bounds[0];
        let right = self.x_bounds[1];
        let top = self.y_bounds[1];
@@ -511,108 +490,13 @@ where
        {
            let x = ((label.x - left) * resolution.0 / width) as u16 + canvas_area.left();
            let y = ((top - label.y) * resolution.1 / height) as u16 + canvas_area.top();
-            buf.set_line(x, y, &label.line, canvas_area.right() - x);
+            buf.set_stringn(
+                x,
+                y,
+                label.text,
+                (canvas_area.right() - x) as usize,
+                style.fg(label.color),
+            );
        }
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use indoc::indoc;
-
-    use super::*;
-    use crate::{buffer::Cell, symbols::Marker};
-
-    // helper to test the canvas checks that drawing a vertical and horizontal line
-    // results in the expected output
-    fn test_marker(marker: Marker, expected: &str) {
-        let area = Rect::new(0, 0, 5, 5);
-        let mut cell = Cell::default();
-        cell.set_char('x');
-        let mut buf = Buffer::filled(area, &cell);
-        let horizontal_line = Line {
-            x1: 0.0,
-            y1: 0.0,
-            x2: 10.0,
-            y2: 0.0,
-            color: Color::Reset,
-        };
-        let vertical_line = Line {
-            x1: 0.0,
-            y1: 0.0,
-            x2: 0.0,
-            y2: 10.0,
-            color: Color::Reset,
-        };
-        Canvas::default()
-            .marker(marker)
-            .paint(|ctx| {
-                ctx.draw(&vertical_line);
-                ctx.draw(&horizontal_line);
-            })
-            .x_bounds([0.0, 10.0])
-            .y_bounds([0.0, 10.0])
-            .render(area, &mut buf);
-        assert_eq!(buf, Buffer::with_lines(expected.lines().collect()));
-    }
-
-    #[test]
-    fn test_bar_marker() {
-        test_marker(
-            Marker::Bar,
-            indoc!(
-                "
-                ▄xxxx
-                ▄xxxx
-                ▄xxxx
-                ▄xxxx
-                ▄▄▄▄▄"
-            ),
-        );
-    }
-
-    #[test]
-    fn test_block_marker() {
-        test_marker(
-            Marker::Block,
-            indoc!(
-                "
-                █xxxx
-                █xxxx
-                █xxxx
-                █xxxx
-                █████"
-            ),
-        );
-    }
-
-    #[test]
-    fn test_braille_marker() {
-        test_marker(
-            Marker::Braille,
-            indoc!(
-                "
-                ⡇xxxx
-                ⡇xxxx
-                ⡇xxxx
-                ⡇xxxx
-                ⣇⣀⣀⣀⣀"
-            ),
-        );
-    }
-
-    #[test]
-    fn test_dot_marker() {
-        test_marker(
-            Marker::Dot,
-            indoc!(
-                "
-                •xxxx
-                •xxxx
-                •xxxx
-                •xxxx
-                •••••"
-            ),
-        );
-    }
-}
--- a/src/widgets/canvas/world.rs
+++ b/src/widgets/canvas/world.rs
@@ -6122,7 +6122,6 @@ pub static WORLD_LOW_RESOLUTION: [(f64, f64); 1166] = [
    (120.43, 16.43),
    (121.72, 18.40),
    (125.34, 9.79),
-    #[allow(clippy::approx_constant)]
    (125.56, 6.28),
    (122.38, 7.00),
    (125.10, 9.38),
--- a/src/widgets/chart.rs
+++ b/src/widgets/chart.rs
@@ -1,32 +1,28 @@
-use std::{borrow::Cow, cmp::max};
-
-use unicode_width::UnicodeWidthStr;
-
 use crate::{
    buffer::Buffer,
-    layout::{Alignment, Constraint, Rect},
+    layout::{Constraint, Rect},
    style::{Color, Style},
    symbols,
-    text::{Line as TextLine, Span},
+    text::{Span, Spans},
    widgets::{
        canvas::{Canvas, Line, Points},
        Block, Borders, Widget,
    },
 };
+use std::{borrow::Cow, cmp::max};
+use unicode_width::UnicodeWidthStr;

 /// An X or Y axis for the chart widget
 #[derive(Debug, Clone)]
 pub struct Axis<'a> {
    /// Title displayed next to axis end
-    title: Option<TextLine<'a>>,
+    title: Option<Spans<'a>>,
    /// Bounds for the axis (all data points outside these limits will not be represented)
    bounds: [f64; 2],
    /// A list of labels to put to the left or below the axis
    labels: Option<Vec<Span<'a>>>,
    /// The style used to draw the axis itself
    style: Style,
-    /// The alignment of the labels of the Axis
-    labels_alignment: Alignment,
 }

 impl<'a> Default for Axis<'a> {
@@ -35,8 +31,7 @@ impl<'a> Default for Axis<'a> {
            title: None,
            bounds: [0.0, 0.0],
            labels: None,
-            style: Style::default(),
-            labels_alignment: Alignment::Left,
+            style: Default::default(),
        }
    }
 }
@@ -44,7 +39,7 @@ impl<'a> Default for Axis<'a> {
 impl<'a> Axis<'a> {
    pub fn title<T>(mut self, title: T) -> Axis<'a>
    where
-        T: Into<TextLine<'a>>,
+        T: Into<Spans<'a>>,
    {
        self.title = Some(title.into());
        self
@@ -52,12 +47,12 @@ impl<'a> Axis<'a> {

    #[deprecated(
        since = "0.10.0",
-        note = "You should use styling capabilities of `text::Line` given as argument of the `title` method to apply styling to the title."
+        note = "You should use styling capabilities of `text::Spans` given as argument of the `title` method to apply styling to the title."
    )]
    pub fn title_style(mut self, style: Style) -> Axis<'a> {
        if let Some(t) = self.title {
            let title = String::from(t);
-            self.title = Some(TextLine::from(Span::styled(title, style)));
+            self.title = Some(Spans::from(Span::styled(title, style)));
        }
        self
    }
@@ -76,15 +71,6 @@ impl<'a> Axis<'a> {
        self.style = style;
        self
    }
-
-    /// Defines the alignment of the labels of the axis.
-    /// The alignment behaves differently based on the axis:
-    /// - Y-Axis: The labels are aligned within the area on the left of the axis
-    /// - X-Axis: The first X-axis label is aligned relative to the Y-axis
-    pub fn labels_alignment(mut self, alignment: Alignment) -> Axis<'a> {
-        self.labels_alignment = alignment;
-        self
-    }
 }

 /// Used to determine which style of graphing to use
@@ -155,7 +141,7 @@ impl<'a> Dataset<'a> {

 /// A container that holds all the infos about where to display each elements of the chart (axis,
 /// labels, legend, ...).
-#[derive(Debug, Clone, PartialEq, Default)]
+#[derive(Debug, Clone, PartialEq)]
 struct ChartLayout {
    /// Location of the title of the x axis
    title_x: Option<(u16, u16)>,
@@ -175,15 +161,30 @@ struct ChartLayout {
    graph_area: Rect,
 }

+impl Default for ChartLayout {
+    fn default() -> ChartLayout {
+        ChartLayout {
+            title_x: None,
+            title_y: None,
+            label_x: None,
+            label_y: None,
+            axis_x: None,
+            axis_y: None,
+            legend_area: None,
+            graph_area: Rect::default(),
+        }
+    }
+}
+
 /// A widget to plot one or more dataset in a cartesian coordinate system
 ///
 /// # Examples
 ///
 /// ```
-/// # use ratatui::symbols;
-/// # use ratatui::widgets::{Block, Borders, Chart, Axis, Dataset, GraphType};
-/// # use ratatui::style::{Style, Color};
-/// # use ratatui::text::Span;
+/// # use tui::symbols;
+/// # use tui::widgets::{Block, Borders, Chart, Axis, Dataset, GraphType};
+/// # use tui::style::{Style, Color};
+/// # use tui::text::Span;
 /// let datasets = vec![
 ///     Dataset::default()
 ///         .name("data1")
@@ -233,7 +234,7 @@ impl<'a> Chart<'a> {
            block: None,
            x_axis: Axis::default(),
            y_axis: Axis::default(),
-            style: Style::default(),
+            style: Default::default(),
            datasets,
            hidden_legend_constraints: (Constraint::Ratio(1, 4), Constraint::Ratio(1, 4)),
        }
@@ -264,8 +265,8 @@ impl<'a> Chart<'a> {
    /// # Examples
    ///
    /// ```
-    /// # use ratatui::widgets::Chart;
-    /// # use ratatui::layout::Constraint;
+    /// # use tui::widgets::Chart;
+    /// # use tui::layout::Constraint;
    /// let constraints = (
    ///     Constraint::Ratio(1, 3),
    ///     Constraint::Ratio(1, 4)
@@ -296,7 +297,7 @@ impl<'a> Chart<'a> {
        }

        layout.label_y = self.y_axis.labels.as_ref().and(Some(x));
-        x += self.max_width_of_labels_left_of_y_axis(area, self.y_axis.labels.is_some());
+        x += self.max_width_of_labels_left_of_y_axis(area);

        if self.x_axis.labels.is_some() && y > area.top() {
            layout.axis_x = Some(y);
@@ -352,27 +353,17 @@ impl<'a> Chart<'a> {
        layout
    }

-    fn max_width_of_labels_left_of_y_axis(&self, area: Rect, has_y_axis: bool) -> u16 {
+    fn max_width_of_labels_left_of_y_axis(&self, area: Rect) -> u16 {
        let mut max_width = self
            .y_axis
            .labels
            .as_ref()
            .map(|l| l.iter().map(Span::width).max().unwrap_or_default() as u16)
            .unwrap_or_default();
-
-        if let Some(first_x_label) = self.x_axis.labels.as_ref().and_then(|labels| labels.get(0)) {
-            let first_label_width = first_x_label.content.width() as u16;
-            let width_left_of_y_axis = match self.x_axis.labels_alignment {
-                Alignment::Left => {
-                    // The last character of the label should be below the Y-Axis when it exists,
-                    // not on its left
-                    let y_axis_offset = u16::from(has_y_axis);
-                    first_label_width.saturating_sub(y_axis_offset)
-                }
-                Alignment::Center => first_label_width / 2,
-                Alignment::Right => 0,
-            };
-            max_width = max(max_width, width_left_of_y_axis);
+        if let Some(ref x_labels) = self.x_axis.labels {
+            if !x_labels.is_empty() {
+                max_width = max(max_width, x_labels[0].content.width() as u16);
+            }
        }
        // labels of y axis and first label of x axis can take at most 1/3rd of the total width
        max_width.min(area.width / 3)
@@ -385,80 +376,35 @@ impl<'a> Chart<'a> {
        chart_area: Rect,
        graph_area: Rect,
    ) {
-        let Some(y) = layout.label_x else { return };
+        let y = match layout.label_x {
+            Some(y) => y,
+            None => return,
+        };
        let labels = self.x_axis.labels.as_ref().unwrap();
        let labels_len = labels.len() as u16;
        if labels_len < 2 {
            return;
        }
-
-        let width_between_ticks = graph_area.width / labels_len;
-
-        let label_area = self.first_x_label_area(
-            y,
-            labels.first().unwrap().width() as u16,
-            width_between_ticks,
-            chart_area,
-            graph_area,
-        );
-
-        let label_alignment = match self.x_axis.labels_alignment {
-            Alignment::Left => Alignment::Right,
-            Alignment::Center => Alignment::Center,
-            Alignment::Right => Alignment::Left,
-        };
-
-        Self::render_label(buf, labels.first().unwrap(), label_area, label_alignment);
-
-        for (i, label) in labels[1..labels.len() - 1].iter().enumerate() {
-            // We add 1 to x (and width-1 below) to leave at least one space before each
-            // intermediate labels
-            let x = graph_area.left() + (i + 1) as u16 * width_between_ticks + 1;
-            let label_area = Rect::new(x, y, width_between_ticks.saturating_sub(1), 1);
-
-            Self::render_label(buf, label, label_area, Alignment::Center);
+        let width_between_ticks = graph_area.width / (labels_len - 1);
+        for (i, label) in labels.iter().enumerate() {
+            let label_width = label.width() as u16;
+            let label_width = if i == 0 {
+                // the first label is put between the left border of the chart and the y axis.
+                graph_area
+                    .left()
+                    .saturating_sub(chart_area.left())
+                    .min(label_width)
+            } else {
+                // other labels are put on the left of each tick on the x axis
+                width_between_ticks.min(label_width)
+            };
+            buf.set_span(
+                graph_area.left() + i as u16 * width_between_ticks - label_width,
+                y,
+                label,
+                label_width,
+            );
        }
-
-        let x = graph_area.right() - width_between_ticks;
-        let label_area = Rect::new(x, y, width_between_ticks, 1);
-        // The last label should be aligned Right to be at the edge of the graph area
-        Self::render_label(buf, labels.last().unwrap(), label_area, Alignment::Right);
-    }
-
-    fn first_x_label_area(
-        &self,
-        y: u16,
-        label_width: u16,
-        max_width_after_y_axis: u16,
-        chart_area: Rect,
-        graph_area: Rect,
-    ) -> Rect {
-        let (min_x, max_x) = match self.x_axis.labels_alignment {
-            Alignment::Left => (chart_area.left(), graph_area.left()),
-            Alignment::Center => (
-                chart_area.left(),
-                graph_area.left() + max_width_after_y_axis.min(label_width),
-            ),
-            Alignment::Right => (
-                graph_area.left().saturating_sub(1),
-                graph_area.left() + max_width_after_y_axis,
-            ),
-        };
-
-        Rect::new(min_x, y, max_x - min_x, 1)
-    }
-
-    fn render_label(buf: &mut Buffer, label: &Span, label_area: Rect, alignment: Alignment) {
-        let label_width = label.width() as u16;
-        let bounded_label_width = label_area.width.min(label_width);
-
-        let x = match alignment {
-            Alignment::Left => label_area.left(),
-            Alignment::Center => label_area.left() + label_area.width / 2 - bounded_label_width / 2,
-            Alignment::Right => label_area.right() - bounded_label_width,
-        };
-
-        buf.set_span(x, label_area.top(), label, bounded_label_width);
    }

    fn render_y_labels(
@@ -468,19 +414,17 @@ impl<'a> Chart<'a> {
        chart_area: Rect,
        graph_area: Rect,
    ) {
-        let Some(x) = layout.label_y else { return };
+        let x = match layout.label_y {
+            Some(x) => x,
+            None => return,
+        };
        let labels = self.y_axis.labels.as_ref().unwrap();
        let labels_len = labels.len() as u16;
+        let label_width = graph_area.left().saturating_sub(chart_area.left());
        for (i, label) in labels.iter().enumerate() {
            let dy = i as u16 * (graph_area.height - 1) / (labels_len - 1);
            if dy < graph_area.bottom() {
-                let label_area = Rect::new(
-                    x,
-                    graph_area.bottom().saturating_sub(1) - dy,
-                    (graph_area.left() - chart_area.left()).saturating_sub(1),
-                    1,
-                );
-                Self::render_label(buf, label, label_area, self.y_axis.labels_alignment);
+                buf.set_span(x, graph_area.bottom() - 1 - dy, label, label_width as u16);
            }
        }
    }
@@ -558,7 +502,7 @@ impl<'a> Widget for Chart<'a> {
                                x2: data[1].0,
                                y2: data[1].1,
                                color: dataset.style.fg.unwrap_or(Color::Reset),
-                            });
+                            })
                        }
                    }
                })
@@ -592,7 +536,7 @@ impl<'a> Widget for Chart<'a> {
                },
                original_style,
            );
-            buf.set_line(x, y, &title, width);
+            buf.set_spans(x, y, &title, width);
        }

        if let Some((x, y)) = layout.title_y {
@@ -607,7 +551,7 @@ impl<'a> Widget for Chart<'a> {
                },
                original_style,
            );
-            buf.set_line(x, y, &title, width);
+            buf.set_spans(x, y, &title, width);
        }
    }
 }
@@ -640,7 +584,7 @@ mod tests {
        for case in &cases {
            let datasets = (0..10)
                .map(|i| {
-                    let name = format!("Dataset #{i}");
+                    let name = format!("Dataset #{}", i);
                    Dataset::default().name(name).data(&data)
                })
                .collect::<Vec<_>>();
--- a/src/widgets/clear.rs
+++ b/src/widgets/clear.rs
@@ -2,16 +2,16 @@ use crate::{buffer::Buffer, layout::Rect, widgets::Widget};

 /// A widget to clear/reset a certain area to allow overdrawing (e.g. for popups).
 ///
-/// This widget **cannot be used to clear the terminal on the first render** as `ratatui` assumes
-/// the render area is empty. Use [`crate::Terminal::clear`] instead.
+/// This widget **cannot be used to clear the terminal on the first render** as `tui` assumes the
+/// render area is empty. Use [`crate::Terminal::clear`] instead.
 ///
 /// # Examples
 ///
 /// ```
-/// # use ratatui::widgets::{Clear, Block, Borders};
-/// # use ratatui::layout::Rect;
-/// # use ratatui::Frame;
-/// # use ratatui::backend::Backend;
+/// # use tui::widgets::{Clear, Block, Borders};
+/// # use tui::layout::Rect;
+/// # use tui::Frame;
+/// # use tui::backend::Backend;
 /// fn draw_on_clear<B: Backend>(f: &mut Frame<B>, area: Rect) {
 ///     let block = Block::default().title("Block").borders(Borders::ALL);
 ///     f.render_widget(Clear, area); // <- this will clear/reset the area first
--- a/src/widgets/gauge.rs
+++ b/src/widgets/gauge.rs
@@ -3,7 +3,7 @@ use crate::{
    layout::Rect,
    style::{Color, Style},
    symbols,
-    text::{Line, Span},
+    text::{Span, Spans},
    widgets::{Block, Widget},
 };

@@ -12,8 +12,8 @@ use crate::{
 /// # Examples:
 ///
 /// ```
-/// # use ratatui::widgets::{Widget, Gauge, Block, Borders};
-/// # use ratatui::style::{Style, Color, Modifier};
+/// # use tui::widgets::{Widget, Gauge, Block, Borders};
+/// # use tui::style::{Style, Color, Modifier};
 /// Gauge::default()
 ///     .block(Block::default().borders(Borders::ALL).title("Progress"))
 ///     .gauge_style(Style::default().fg(Color::White).bg(Color::Black).add_modifier(Modifier::ITALIC))
@@ -111,7 +111,8 @@ impl<'a> Widget for Gauge<'a> {
        // label is put at the center of the gauge_area
        let label = {
            let pct = f64::round(self.ratio * 100.0);
-            self.label.unwrap_or_else(|| Span::from(format!("{pct}%")))
+            self.label
+                .unwrap_or_else(|| Span::from(format!("{}%", pct)))
        };
        let clamped_label_width = gauge_area.width.min(label.width() as u16);
        let label_col = gauge_area.left() + (gauge_area.width - clamped_label_width) / 2;
@@ -127,26 +128,18 @@ impl<'a> Widget for Gauge<'a> {
        for y in gauge_area.top()..gauge_area.bottom() {
            // render the filled area (left to end)
            for x in gauge_area.left()..end {
-                let cell = buf.get_mut(x, y);
-                if self.use_unicode {
-                    cell.set_symbol(symbols::block::FULL)
-                        .set_fg(self.gauge_style.fg.unwrap_or(Color::Reset))
-                        .set_bg(self.gauge_style.bg.unwrap_or(Color::Reset));
-                } else {
-                    // spaces are needed to apply the background styling.
-                    // note that the background and foreground colors are swapped
-                    // otherwise the gauge will be inverted
-                    cell.set_symbol(" ")
-                        .set_fg(self.gauge_style.bg.unwrap_or(Color::Reset))
-                        .set_bg(self.gauge_style.fg.unwrap_or(Color::Reset));
-                }
+                // spaces are needed to apply the background styling
+                buf.get_mut(x, y)
+                    .set_symbol(" ")
+                    .set_fg(self.gauge_style.bg.unwrap_or(Color::Reset))
+                    .set_bg(self.gauge_style.fg.unwrap_or(Color::Reset));
            }
            if self.use_unicode && self.ratio < 1.0 {
                buf.get_mut(end, y)
                    .set_symbol(get_unicode_block(filled_width % 1.0));
            }
        }
-        // render the label
+        // set the span
        buf.set_span(label_col, label_row, &label, clamped_label_width);
    }
 }
@@ -170,9 +163,9 @@ fn get_unicode_block<'a>(frac: f64) -> &'a str {
 /// # Examples:
 ///
 /// ```
-/// # use ratatui::widgets::{Widget, LineGauge, Block, Borders};
-/// # use ratatui::style::{Style, Color, Modifier};
-/// # use ratatui::symbols;
+/// # use tui::widgets::{Widget, LineGauge, Block, Borders};
+/// # use tui::style::{Style, Color, Modifier};
+/// # use tui::symbols;
 /// LineGauge::default()
 ///     .block(Block::default().borders(Borders::ALL).title("Progress"))
 ///     .gauge_style(Style::default().fg(Color::White).bg(Color::Black).add_modifier(Modifier::BOLD))
@@ -182,7 +175,7 @@ fn get_unicode_block<'a>(frac: f64) -> &'a str {
 pub struct LineGauge<'a> {
    block: Option<Block<'a>>,
    ratio: f64,
-    label: Option<Line<'a>>,
+    label: Option<Spans<'a>>,
    line_set: symbols::line::Set,
    style: Style,
    gauge_style: Style,
@@ -223,7 +216,7 @@ impl<'a> LineGauge<'a> {

    pub fn label<T>(mut self, label: T) -> Self
    where
-        T: Into<Line<'a>>,
+        T: Into<Spans<'a>>,
    {
        self.label = Some(label.into());
        self
@@ -259,8 +252,8 @@ impl<'a> Widget for LineGauge<'a> {
        let ratio = self.ratio;
        let label = self
            .label
-            .unwrap_or_else(move || Line::from(format!("{:.0}%", ratio * 100.0)));
-        let (col, row) = buf.set_line(
+            .unwrap_or_else(move || Spans::from(format!("{:.0}%", ratio * 100.0)));
+        let (col, row) = buf.set_spans(
            gauge_area.left(),
            gauge_area.top(),
            &label,
--- a/src/widgets/list.rs
+++ b/src/widgets/list.rs
@@ -1,4 +1,4 @@
-use unicode_width::UnicodeWidthStr;
+use std::collections::BTreeSet;

 use crate::{
    buffer::Buffer,
@@ -7,45 +7,47 @@ use crate::{
    text::Text,
    widgets::{Block, StatefulWidget, Widget},
 };
+use unicode_width::UnicodeWidthStr;

-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct ListState {
    offset: usize,
-    selected: Option<usize>,
+    selected: BTreeSet<usize>,
 }

-impl ListState {
-    pub fn offset(&self) -> usize {
-        self.offset
-    }
-
-    pub fn offset_mut(&mut self) -> &mut usize {
-        &mut self.offset
-    }
-
-    pub fn with_selected(mut self, selected: Option<usize>) -> Self {
-        self.selected = selected;
-        self
-    }
-
-    pub fn with_offset(mut self, offset: usize) -> Self {
-        self.offset = offset;
-        self
-    }
-
-    pub fn selected(&self) -> Option<usize> {
-        self.selected
-    }
-
-    pub fn select(&mut self, index: Option<usize>) {
-        self.selected = index;
-        if index.is_none() {
-            self.offset = 0;
+impl Default for ListState {
+    fn default() -> ListState {
+        ListState {
+            offset: 0,
+            selected: BTreeSet::new(),
        }
    }
 }

-#[derive(Debug, Clone, PartialEq, Eq)]
+impl ListState {
+    pub fn offset(mut self, offset: usize) -> Self {
+        self.offset = offset;
+        self
+    }
+    
+    pub fn selected(&self) -> &BTreeSet<usize> {
+        &self.selected
+    }
+
+    pub fn select(&mut self, index: usize) {
+        self.selected.insert(index);
+    }
+
+    pub fn deselect(&mut self, index: usize) {
+        self.selected.remove(&index);
+    }
+
+    pub fn deselect_all(&mut self) {
+        self.selected.clear();
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
 pub struct ListItem<'a> {
    content: Text<'a>,
    style: Style,
@@ -70,10 +72,6 @@ impl<'a> ListItem<'a> {
    pub fn height(&self) -> usize {
        self.content.height()
    }
-
-    pub fn width(&self) -> usize {
-        self.content.width()
-    }
 }

 /// A widget to display several items among which one can be selected (optional)
@@ -81,8 +79,8 @@ impl<'a> ListItem<'a> {
 /// # Examples
 ///
 /// ```
-/// # use ratatui::widgets::{Block, Borders, List, ListItem};
-/// # use ratatui::style::{Style, Color, Modifier};
+/// # use tui::widgets::{Block, Borders, List, ListItem};
+/// # use tui::style::{Style, Color, Modifier};
 /// let items = [ListItem::new("Item 1"), ListItem::new("Item 2"), ListItem::new("Item 3")];
 /// List::new(items)
 ///     .block(Block::default().title("List").borders(Borders::ALL))
@@ -101,8 +99,6 @@ pub struct List<'a> {
    highlight_style: Style,
    /// Symbol in front of the selected item (Shift all items to the right)
    highlight_symbol: Option<&'a str>,
-    /// Whether to repeat the highlight symbol for each line of the selected item
-    repeat_highlight_symbol: bool,
 }

 impl<'a> List<'a> {
@@ -117,7 +113,6 @@ impl<'a> List<'a> {
            start_corner: Corner::TopLeft,
            highlight_style: Style::default(),
            highlight_symbol: None,
-            repeat_highlight_symbol: false,
        }
    }

@@ -141,27 +136,13 @@ impl<'a> List<'a> {
        self
    }

-    pub fn repeat_highlight_symbol(mut self, repeat: bool) -> List<'a> {
-        self.repeat_highlight_symbol = repeat;
-        self
-    }
-
    pub fn start_corner(mut self, corner: Corner) -> List<'a> {
        self.start_corner = corner;
        self
    }

-    pub fn len(&self) -> usize {
-        self.items.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.items.is_empty()
-    }
-
    fn get_items_bounds(
        &self,
-        selected: Option<usize>,
        offset: usize,
        max_height: usize,
    ) -> (usize, usize) {
@@ -169,6 +150,9 @@ impl<'a> List<'a> {
        let mut start = offset;
        let mut end = offset;
        let mut height = 0;
+
+        // Fills forwards until max_height is reached
+        // or no more items are left.
        for item in self.items.iter().skip(offset) {
            if height + item.height() > max_height {
                break;
@@ -176,24 +160,17 @@ impl<'a> List<'a> {
            height += item.height();
            end += 1;
        }
-
-        let selected = selected.unwrap_or(0).min(self.items.len() - 1);
-        while selected >= end {
-            height = height.saturating_add(self.items[end].height());
-            end += 1;
-            while height > max_height {
-                height = height.saturating_sub(self.items[start].height());
-                start += 1;
+        
+        // Fills backwards, if offset is too large
+        // and we have insufficient items.
+        for item in self.items[..start].iter().rev() {
+            if height + item.height() > max_height {
+                break;
            }
-        }
-        while selected < start {
+            height += item.height();
            start -= 1;
-            height = height.saturating_add(self.items[start].height());
-            while height > max_height {
-                end -= 1;
-                height = height.saturating_sub(self.items[end].height());
-            }
        }
+
        (start, end)
    }
 }
@@ -221,28 +198,30 @@ impl<'a> StatefulWidget for List<'a> {
        }
        let list_height = list_area.height as usize;

-        let (start, end) = self.get_items_bounds(state.selected, state.offset, list_height);
-        state.offset = start;
+        let (start, end) = self.get_items_bounds(state.offset, list_height);

        let highlight_symbol = self.highlight_symbol.unwrap_or("");
        let blank_symbol = " ".repeat(highlight_symbol.width());

        let mut current_height = 0;
-        let has_selection = state.selected.is_some();
+        let has_selection = !state.selected.is_empty();
        for (i, item) in self
            .items
            .iter_mut()
            .enumerate()
-            .skip(state.offset)
+            .skip(start)
            .take(end - start)
        {
-            let (x, y) = if self.start_corner == Corner::BottomLeft {
-                current_height += item.height() as u16;
-                (list_area.left(), list_area.bottom() - current_height)
-            } else {
-                let pos = (list_area.left(), list_area.top() + current_height);
-                current_height += item.height() as u16;
-                pos
+            let (x, y) = match self.start_corner {
+                Corner::BottomLeft => {
+                    current_height += item.height() as u16;
+                    (list_area.left(), list_area.bottom() - current_height)
+                }
+                _ => {
+                    let pos = (list_area.left(), list_area.top() + current_height);
+                    current_height += item.height() as u16;
+                    pos
+                }
            };
            let area = Rect {
                x,
@@ -253,29 +232,21 @@ impl<'a> StatefulWidget for List<'a> {
            let item_style = self.style.patch(item.style);
            buf.set_style(area, item_style);

-            let is_selected = state.selected.map_or(false, |s| s == i);
-            for (j, line) in item.content.lines.iter().enumerate() {
-                // if the item is selected, we need to display the highlight symbol:
-                // - either for the first line of the item only,
-                // - or for each line of the item if the appropriate option is set
-                let symbol = if is_selected && (j == 0 || self.repeat_highlight_symbol) {
+            let is_selected = state.selected.contains(&i);
+            let elem_x = if has_selection {
+                let symbol = if is_selected {
                    highlight_symbol
                } else {
                    &blank_symbol
                };
-                let (elem_x, max_element_width) = if has_selection {
-                    let (elem_x, _) = buf.set_stringn(
-                        x,
-                        y + j as u16,
-                        symbol,
-                        list_area.width as usize,
-                        item_style,
-                    );
-                    (elem_x, (list_area.width - (elem_x - x)))
-                } else {
-                    (x, list_area.width)
-                };
-                buf.set_line(elem_x, y + j as u16, line, max_element_width);
+                let (x, _) = buf.set_stringn(x, y, symbol, list_area.width as usize, item_style);
+                x
+            } else {
+                x
+            };
+            let max_element_width = (list_area.width - (elem_x - x)) as usize;
+            for (j, line) in item.content.lines.iter().enumerate() {
+                buf.set_spans(elem_x, y + j as u16, line, max_element_width as u16);
            }
            if is_selected {
                buf.set_style(area, self.highlight_style);
@@ -290,594 +261,3 @@ impl<'a> Widget for List<'a> {
        StatefulWidget::render(self, area, buf, &mut state);
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use std::borrow::Cow;
-
-    use super::*;
-    use crate::{
-        assert_buffer_eq,
-        style::Color,
-        text::{Line, Span},
-        widgets::{Borders, StatefulWidget, Widget},
-    };
-
-    #[test]
-    fn test_list_state_selected() {
-        let mut state = ListState::default();
-        assert_eq!(state.selected(), None);
-
-        state.select(Some(1));
-        assert_eq!(state.selected(), Some(1));
-
-        state.select(None);
-        assert_eq!(state.selected(), None);
-    }
-
-    #[test]
-    fn test_list_state_select() {
-        let mut state = ListState::default();
-        assert_eq!(state.selected, None);
-        assert_eq!(state.offset, 0);
-
-        state.select(Some(2));
-        assert_eq!(state.selected, Some(2));
-        assert_eq!(state.offset, 0);
-
-        state.select(None);
-        assert_eq!(state.selected, None);
-        assert_eq!(state.offset, 0);
-    }
-
-    #[test]
-    fn test_list_item_new_from_str() {
-        let item = ListItem::new("Test item");
-        assert_eq!(item.content, Text::from("Test item"));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn test_list_item_new_from_string() {
-        let item = ListItem::new("Test item".to_string());
-        assert_eq!(item.content, Text::from("Test item"));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn test_list_item_new_from_cow_str() {
-        let item = ListItem::new(Cow::Borrowed("Test item"));
-        assert_eq!(item.content, Text::from("Test item"));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn test_list_item_new_from_span() {
-        let span = Span::styled("Test item", Style::default().fg(Color::Blue));
-        let item = ListItem::new(span.clone());
-        assert_eq!(item.content, Text::from(span));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn test_list_item_new_from_spans() {
-        let spans = Line::from(vec![
-            Span::styled("Test ", Style::default().fg(Color::Blue)),
-            Span::styled("item", Style::default().fg(Color::Red)),
-        ]);
-        let item = ListItem::new(spans.clone());
-        assert_eq!(item.content, Text::from(spans));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn test_list_item_new_from_vec_spans() {
-        let lines = vec![
-            Line::from(vec![
-                Span::styled("Test ", Style::default().fg(Color::Blue)),
-                Span::styled("item", Style::default().fg(Color::Red)),
-            ]),
-            Line::from(vec![
-                Span::styled("Second ", Style::default().fg(Color::Green)),
-                Span::styled("line", Style::default().fg(Color::Yellow)),
-            ]),
-        ];
-        let item = ListItem::new(lines.clone());
-        assert_eq!(item.content, Text::from(lines));
-        assert_eq!(item.style, Style::default());
-    }
-
-    #[test]
-    fn test_list_item_style() {
-        let item = ListItem::new("Test item").style(Style::default().bg(Color::Red));
-        assert_eq!(item.content, Text::from("Test item"));
-        assert_eq!(item.style, Style::default().bg(Color::Red));
-    }
-
-    #[test]
-    fn test_list_item_height() {
-        let item = ListItem::new("Test item");
-        assert_eq!(item.height(), 1);
-
-        let item = ListItem::new("Test item\nSecond line");
-        assert_eq!(item.height(), 2);
-    }
-
-    #[test]
-    fn test_list_item_width() {
-        let item = ListItem::new("Test item");
-        assert_eq!(item.width(), 9);
-    }
-
-    /// helper method to take a vector of strings and return a vector of list items
-    fn list_items(items: Vec<&str>) -> Vec<ListItem> {
-        items.iter().map(|i| ListItem::new(i.to_string())).collect()
-    }
-
-    /// helper method to render a widget to an empty buffer with the default state
-    fn render_widget(widget: List<'_>, width: u16, height: u16) -> Buffer {
-        let mut buffer = Buffer::empty(Rect::new(0, 0, width, height));
-        Widget::render(widget, buffer.area, &mut buffer);
-        buffer
-    }
-
-    /// helper method to render a widget to an empty buffer with a given state
-    fn render_stateful_widget(
-        widget: List<'_>,
-        state: &mut ListState,
-        width: u16,
-        height: u16,
-    ) -> Buffer {
-        let mut buffer = Buffer::empty(Rect::new(0, 0, width, height));
-        StatefulWidget::render(widget, buffer.area, &mut buffer, state);
-        buffer
-    }
-
-    #[test]
-    fn test_list_does_not_render_in_small_space() {
-        let items = list_items(vec!["Item 0", "Item 1", "Item 2"]);
-        let list = List::new(items.clone()).highlight_symbol(">>");
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 15, 3));
-
-        // attempt to render into an area of the buffer with 0 width
-        Widget::render(list.clone(), Rect::new(0, 0, 0, 3), &mut buffer);
-        assert_buffer_eq!(buffer, Buffer::empty(buffer.area));
-
-        // attempt to render into an area of the buffer with 0 height
-        Widget::render(list.clone(), Rect::new(0, 0, 15, 0), &mut buffer);
-        assert_buffer_eq!(buffer, Buffer::empty(buffer.area));
-
-        let list = List::new(items)
-            .highlight_symbol(">>")
-            .block(Block::default().borders(Borders::all()));
-        // attempt to render into an area of the buffer with zero height after
-        // setting the block borders
-        Widget::render(list, Rect::new(0, 0, 15, 2), &mut buffer);
-        assert_buffer_eq!(
-            buffer,
-            Buffer::with_lines(vec![
-                "┌─────────────┐",
-                "└─────────────┘",
-                "               "
-            ])
-        );
-    }
-
-    #[test]
-    fn test_list_combinations() {
-        fn test_case_render(items: &[ListItem], expected_lines: Vec<&str>) {
-            let list = List::new(items.to_owned()).highlight_symbol(">>");
-            let mut buffer = Buffer::empty(Rect::new(0, 0, 10, 5));
-
-            Widget::render(list, buffer.area, &mut buffer);
-
-            let expected = Buffer::with_lines(expected_lines);
-            assert_buffer_eq!(buffer, expected);
-        }
-        fn test_case_render_stateful(
-            items: &[ListItem],
-            selected: Option<usize>,
-            expected_lines: Vec<&str>,
-        ) {
-            let list = List::new(items.to_owned()).highlight_symbol(">>");
-            let mut state = ListState::default().with_selected(selected);
-            let mut buffer = Buffer::empty(Rect::new(0, 0, 10, 5));
-
-            StatefulWidget::render(list, buffer.area, &mut buffer, &mut state);
-
-            let expected = Buffer::with_lines(expected_lines);
-            assert_buffer_eq!(buffer, expected);
-        }
-
-        let empty_items: Vec<ListItem> = Vec::new();
-        let single_item = list_items(vec!["Item 0"]);
-        let multiple_items = list_items(vec!["Item 0", "Item 1", "Item 2"]);
-        let multi_line_items = list_items(vec!["Item 0\nLine 2", "Item 1", "Item 2"]);
-
-        // empty list
-        test_case_render(
-            &empty_items,
-            vec![
-                "          ",
-                "          ",
-                "          ",
-                "          ",
-                "          ",
-            ],
-        );
-        test_case_render_stateful(
-            &empty_items,
-            None,
-            vec![
-                "          ",
-                "          ",
-                "          ",
-                "          ",
-                "          ",
-            ],
-        );
-        test_case_render_stateful(
-            &empty_items,
-            Some(0),
-            vec![
-                "          ",
-                "          ",
-                "          ",
-                "          ",
-                "          ",
-            ],
-        );
-
-        // single item
-        test_case_render(
-            &single_item,
-            vec![
-                "Item 0    ",
-                "          ",
-                "          ",
-                "          ",
-                "          ",
-            ],
-        );
-        test_case_render_stateful(
-            &single_item,
-            None,
-            vec![
-                "Item 0    ",
-                "          ",
-                "          ",
-                "          ",
-                "          ",
-            ],
-        );
-        test_case_render_stateful(
-            &single_item,
-            Some(0),
-            vec![
-                ">>Item 0  ",
-                "          ",
-                "          ",
-                "          ",
-                "          ",
-            ],
-        );
-        test_case_render_stateful(
-            &single_item,
-            Some(1),
-            vec![
-                "  Item 0  ",
-                "          ",
-                "          ",
-                "          ",
-                "          ",
-            ],
-        );
-
-        // multiple items
-        test_case_render(
-            &multiple_items,
-            vec![
-                "Item 0    ",
-                "Item 1    ",
-                "Item 2    ",
-                "          ",
-                "          ",
-            ],
-        );
-        test_case_render_stateful(
-            &multiple_items,
-            None,
-            vec![
-                "Item 0    ",
-                "Item 1    ",
-                "Item 2    ",
-                "          ",
-                "          ",
-            ],
-        );
-        test_case_render_stateful(
-            &multiple_items,
-            Some(0),
-            vec![
-                ">>Item 0  ",
-                "  Item 1  ",
-                "  Item 2  ",
-                "          ",
-                "          ",
-            ],
-        );
-        test_case_render_stateful(
-            &multiple_items,
-            Some(1),
-            vec![
-                "  Item 0  ",
-                ">>Item 1  ",
-                "  Item 2  ",
-                "          ",
-                "          ",
-            ],
-        );
-        test_case_render_stateful(
-            &multiple_items,
-            Some(3),
-            vec![
-                "  Item 0  ",
-                "  Item 1  ",
-                "  Item 2  ",
-                "          ",
-                "          ",
-            ],
-        );
-
-        // multi line items
-        test_case_render(
-            &multi_line_items,
-            vec![
-                "Item 0    ",
-                "Line 2    ",
-                "Item 1    ",
-                "Item 2    ",
-                "          ",
-            ],
-        );
-        test_case_render_stateful(
-            &multi_line_items,
-            None,
-            vec![
-                "Item 0    ",
-                "Line 2    ",
-                "Item 1    ",
-                "Item 2    ",
-                "          ",
-            ],
-        );
-        test_case_render_stateful(
-            &multi_line_items,
-            Some(0),
-            vec![
-                ">>Item 0  ",
-                "  Line 2  ",
-                "  Item 1  ",
-                "  Item 2  ",
-                "          ",
-            ],
-        );
-        test_case_render_stateful(
-            &multi_line_items,
-            Some(1),
-            vec![
-                "  Item 0  ",
-                "  Line 2  ",
-                ">>Item 1  ",
-                "  Item 2  ",
-                "          ",
-            ],
-        );
-    }
-
-    #[test]
-    fn test_list_with_empty_strings() {
-        let items = list_items(vec!["Item 0", "", "", "Item 1", "Item 2"]);
-        let list = List::new(items).block(Block::default().title("List").borders(Borders::ALL));
-        let buffer = render_widget(list, 10, 7);
-
-        let expected = Buffer::with_lines(vec![
-            "┌List────┐",
-            "│Item 0  │",
-            "│        │",
-            "│        │",
-            "│Item 1  │",
-            "│Item 2  │",
-            "└────────┘",
-        ]);
-        assert_buffer_eq!(buffer, expected);
-    }
-
-    #[test]
-    fn test_list_block() {
-        let items = list_items(vec!["Item 0", "Item 1", "Item 2"]);
-        let list = List::new(items).block(Block::default().title("List").borders(Borders::ALL));
-        let buffer = render_widget(list, 10, 7);
-
-        let expected = Buffer::with_lines(vec![
-            "┌List────┐",
-            "│Item 0  │",
-            "│Item 1  │",
-            "│Item 2  │",
-            "│        │",
-            "│        │",
-            "└────────┘",
-        ]);
-        assert_buffer_eq!(buffer, expected);
-    }
-
-    #[test]
-    fn test_list_style() {
-        let items = list_items(vec!["Item 0", "Item 1", "Item 2"]);
-        let list = List::new(items).style(Style::default().fg(Color::Red));
-        let buffer = render_widget(list, 10, 5);
-
-        let mut expected = Buffer::with_lines(vec![
-            "Item 0    ",
-            "Item 1    ",
-            "Item 2    ",
-            "          ",
-            "          ",
-        ]);
-        expected.set_style(buffer.area, Style::default().fg(Color::Red));
-        assert_buffer_eq!(buffer, expected);
-    }
-
-    #[test]
-    fn test_list_highlight_symbol_and_style() {
-        let items = list_items(vec!["Item 0", "Item 1", "Item 2"]);
-        let list = List::new(items)
-            .highlight_symbol(">>")
-            .highlight_style(Style::default().fg(Color::Yellow));
-        let mut state = ListState::default();
-        state.select(Some(1));
-
-        let buffer = render_stateful_widget(list, &mut state, 10, 5);
-
-        let mut expected = Buffer::with_lines(vec![
-            "  Item 0  ",
-            ">>Item 1  ",
-            "  Item 2  ",
-            "          ",
-            "          ",
-        ]);
-        expected.set_style(Rect::new(0, 1, 10, 1), Style::default().fg(Color::Yellow));
-        assert_buffer_eq!(buffer, expected);
-    }
-
-    #[test]
-    fn test_list_repeat_highlight_symbol() {
-        let items = list_items(vec!["Item 0\nLine 2", "Item 1", "Item 2"]);
-        let list = List::new(items)
-            .highlight_symbol(">>")
-            .highlight_style(Style::default().fg(Color::Yellow))
-            .repeat_highlight_symbol(true);
-        let mut state = ListState::default();
-        state.select(Some(0));
-
-        let buffer = render_stateful_widget(list, &mut state, 10, 5);
-
-        let mut expected = Buffer::with_lines(vec![
-            ">>Item 0  ",
-            ">>Line 2  ",
-            "  Item 1  ",
-            "  Item 2  ",
-            "          ",
-        ]);
-        expected.set_style(Rect::new(0, 0, 10, 2), Style::default().fg(Color::Yellow));
-        assert_buffer_eq!(buffer, expected);
-    }
-
-    #[test]
-    fn test_list_start_corner_top_left() {
-        let items = list_items(vec!["Item 0", "Item 1", "Item 2"]);
-        let list = List::new(items).start_corner(Corner::TopLeft);
-        let buffer = render_widget(list, 10, 5);
-        let expected = Buffer::with_lines(vec![
-            "Item 0    ",
-            "Item 1    ",
-            "Item 2    ",
-            "          ",
-            "          ",
-        ]);
-        assert_buffer_eq!(buffer, expected);
-    }
-
-    #[test]
-    fn test_list_start_corner_bottom_left() {
-        let items = list_items(vec!["Item 0", "Item 1", "Item 2"]);
-        let list = List::new(items).start_corner(Corner::BottomLeft);
-        let buffer = render_widget(list, 10, 5);
-        let expected = Buffer::with_lines(vec![
-            "          ",
-            "          ",
-            "Item 2    ",
-            "Item 1    ",
-            "Item 0    ",
-        ]);
-        assert_buffer_eq!(buffer, expected);
-    }
-
-    #[test]
-    fn test_list_truncate_items() {
-        let items = list_items(vec!["Item 0", "Item 1", "Item 2", "Item 3", "Item 4"]);
-        let list = List::new(items);
-        let buffer = render_widget(list, 10, 3);
-        let expected = Buffer::with_lines(vec!["Item 0    ", "Item 1    ", "Item 2    "]);
-        assert_buffer_eq!(buffer, expected);
-    }
-
-    #[test]
-    fn test_list_long_lines() {
-        let items = list_items(vec![
-            "Item 0 with a very long line that will be truncated",
-            "Item 1",
-            "Item 2",
-        ]);
-        let list = List::new(items).highlight_symbol(">>");
-
-        fn test_case(list: List, selected: Option<usize>, expected_lines: Vec<&str>) {
-            let mut state = ListState::default();
-            state.select(selected);
-            let buffer = render_stateful_widget(list.clone(), &mut state, 15, 3);
-            let expected = Buffer::with_lines(expected_lines);
-            assert_buffer_eq!(buffer, expected);
-        }
-
-        test_case(
-            list.clone(),
-            None,
-            vec!["Item 0 with a v", "Item 1         ", "Item 2         "],
-        );
-        test_case(
-            list,
-            Some(0),
-            vec![">>Item 0 with a", "  Item 1       ", "  Item 2       "],
-        );
-    }
-
-    #[test]
-    fn test_list_selected_item_ensures_selected_item_is_visible_when_offset_is_before_visible_range(
-    ) {
-        let items = list_items(vec![
-            "Item 0", "Item 1", "Item 2", "Item 3", "Item 4", "Item 5", "Item 6",
-        ]);
-        let list = List::new(items).highlight_symbol(">>");
-        // Set the initial visible range to items 3, 4, and 5
-        let mut state = ListState::default().with_selected(Some(1)).with_offset(3);
-        let buffer = render_stateful_widget(list, &mut state, 10, 3);
-
-        let expected = Buffer::with_lines(vec![">>Item 1  ", "  Item 2  ", "  Item 3  "]);
-        assert_buffer_eq!(buffer, expected);
-        assert_eq!(state.selected, Some(1));
-        assert_eq!(
-            state.offset, 1,
-            "did not scroll the selected item into view"
-        );
-    }
-
-    #[test]
-    fn test_list_selected_item_ensures_selected_item_is_visible_when_offset_is_after_visible_range()
-    {
-        let items = list_items(vec![
-            "Item 0", "Item 1", "Item 2", "Item 3", "Item 4", "Item 5", "Item 6",
-        ]);
-        let list = List::new(items).highlight_symbol(">>");
-        // Set the initial visible range to items 3, 4, and 5
-        let mut state = ListState::default().with_selected(Some(6)).with_offset(3);
-        let buffer = render_stateful_widget(list, &mut state, 10, 3);
-
-        let expected = Buffer::with_lines(vec!["  Item 4  ", "  Item 5  ", ">>Item 6  "]);
-        assert_buffer_eq!(buffer, expected);
-        assert_eq!(state.selected, Some(6));
-        assert_eq!(
-            state.offset, 4,
-            "did not scroll the selected item into view"
-        );
-    }
-}
--- a/src/widgets/mod.rs
+++ b/src/widgets/mod.rs
@@ -13,13 +13,10 @@
 //! - [`BarChart`]
 //! - [`Gauge`]
 //! - [`Sparkline`]
-//! - [`calendar::Monthly`]
 //! - [`Clear`]

 mod barchart;
-pub mod block;
-#[cfg(feature = "widget-calendar")]
-pub mod calendar;
+mod block;
 pub mod canvas;
 mod chart;
 mod clear;
@@ -27,76 +24,39 @@ mod gauge;
 mod list;
 mod paragraph;
 mod reflow;
-pub mod scrollbar;
 mod sparkline;
 mod table;
 mod tabs;

-use std::fmt::{self, Debug};
+pub use self::barchart::BarChart;
+pub use self::block::{Block, BorderType};
+pub use self::chart::{Axis, Chart, Dataset, GraphType};
+pub use self::clear::Clear;
+pub use self::gauge::{Gauge, LineGauge};
+pub use self::list::{List, ListItem, ListState};
+pub use self::paragraph::{Paragraph, Wrap};
+pub use self::sparkline::Sparkline;
+pub use self::table::{Cell, Row, Table, TableState};
+pub use self::tabs::Tabs;

-use bitflags::bitflags;
-
-pub use self::{
-    barchart::BarChart,
-    block::{Block, BorderType, Padding},
-    chart::{Axis, Chart, Dataset, GraphType},
-    clear::Clear,
-    gauge::{Gauge, LineGauge},
-    list::{List, ListItem, ListState},
-    paragraph::{Paragraph, Wrap},
-    scrollbar::{ScrollDirection, Scrollbar, ScrollbarOrientation, ScrollbarState},
-    sparkline::{RenderDirection, Sparkline},
-    table::{Cell, Row, Table, TableState},
-    tabs::Tabs,
-};
 use crate::{buffer::Buffer, layout::Rect};
+use bitflags::bitflags;

 bitflags! {
    /// Bitflags that can be composed to set the visible borders essentially on the block widget.
-    #[derive(Clone, Copy, Default, PartialEq, Eq)]
-    pub struct Borders: u8 {
+    pub struct Borders: u32 {
        /// Show no border (default)
-        const NONE   = 0b0000;
+        const NONE  = 0b0000_0001;
        /// Show the top border
-        const TOP    = 0b0001;
+        const TOP   = 0b0000_0010;
        /// Show the right border
-        const RIGHT  = 0b0010;
+        const RIGHT = 0b0000_0100;
        /// Show the bottom border
-        const BOTTOM = 0b0100;
+        const BOTTOM = 0b000_1000;
        /// Show the left border
-        const LEFT   = 0b1000;
+        const LEFT = 0b0001_0000;
        /// Show all borders
-        const ALL = Self::TOP.bits() | Self::RIGHT.bits() | Self::BOTTOM.bits() | Self::LEFT.bits();
-    }
-}
-
-/// Implement the `Debug` trait for the `Borders` bitflags. This is a manual implementation to
-/// display the flags in a more readable way. The default implementation would display the
-/// flags as 'Border(0x0)' for `Borders::NONE` for example.
-impl Debug for Borders {
-    /// Display the Borders bitflags as a list of names. For example, `Borders::NONE` will be
-    /// displayed as `NONE` and `Borders::ALL` will be displayed as `ALL`. If multiple flags are
-    /// set, they will be displayed separated by a pipe character.
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if self.is_empty() {
-            return write!(f, "NONE");
-        }
-        if self.is_all() {
-            return write!(f, "ALL");
-        }
-        let mut first = true;
-        for (name, border) in self.iter_names() {
-            if border == Borders::NONE {
-                continue;
-            }
-            if first {
-                write!(f, "{name}")?;
-                first = false;
-            } else {
-                write!(f, " | {name}")?;
-            }
-        }
-        Ok(())
+        const ALL = Self::TOP.bits | Self::RIGHT.bits | Self::BOTTOM.bits | Self::LEFT.bits;
    }
 }

@@ -126,9 +86,9 @@ pub trait Widget {
 ///
 /// ```rust,no_run
 /// # use std::io;
-/// # use ratatui::Terminal;
-/// # use ratatui::backend::{Backend, TestBackend};
-/// # use ratatui::widgets::{Widget, List, ListItem, ListState};
+/// # use tui::Terminal;
+/// # use tui::backend::{Backend, TermionBackend};
+/// # use tui::widgets::{Widget, List, ListItem, ListState};
 ///
 /// // Let's say we have some events to display.
 /// struct Events {
@@ -194,8 +154,9 @@ pub trait Widget {
 ///     }
 /// }
 ///
-/// # let backend = TestBackend::new(5, 5);
-/// # let mut terminal = Terminal::new(backend).unwrap();
+/// let stdout = io::stdout();
+/// let backend = TermionBackend::new(stdout);
+/// let mut terminal = Terminal::new(backend).unwrap();
 ///
 /// let mut events = Events::new(vec![
 ///     String::from("Item 1"),
@@ -205,8 +166,8 @@ pub trait Widget {
 /// loop {
 ///     terminal.draw(|f| {
 ///         // The items managed by the application are transformed to something
-///         // that is understood by ratatui.
-///         let items: Vec<ListItem>= events.items.iter().map(|i| ListItem::new(i.as_str())).collect();
+///         // that is understood by tui.
+///         let items: Vec<ListItem>= events.items.iter().map(|i| ListItem::new(i.as_ref())).collect();
 ///         // The `List` widget is then built with those items.
 ///         let list = List::new(items);
 ///         // Finally the widget is rendered using the associated state. `events.state` is
@@ -222,62 +183,3 @@ pub trait StatefulWidget {
    type State;
    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State);
 }
-
-/// Macro that constructs and returns a [`Borders`] object from TOP, BOTTOM, LEFT, RIGHT, NONE, and
-/// ALL. Internally it creates an empty `Borders` object and then inserts each bit flag specified
-/// into it using `Borders::insert()`.
-///
-/// ## Examples
-///
-///```
-/// # use ratatui::widgets::{Block, Borders};
-/// # use ratatui::style::{Style, Color};
-/// # use ratatui::border;
-///
-/// Block::default()
-///     //Construct a `Borders` object and use it in place
-///     .borders(border!(TOP, BOTTOM));
-///
-/// //`border!` can be called with any order of individual sides
-/// let bottom_first = border!(BOTTOM, LEFT, TOP);
-/// //with the ALL keyword which works as expected
-/// let all = border!(ALL);
-/// //or with nothing to return a `Borders::NONE' bitflag.
-/// let none = border!(NONE);
-/// ```
-#[cfg(feature = "macros")]
-#[macro_export]
-macro_rules! border {
-    ( $($b:tt), +) => {{
-            let mut border = Borders::empty();
-            $(
-               border.insert(Borders::$b);
-            )*
-            border
-    }};
-    () =>{
-        Borders::NONE
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_borders_debug() {
-        assert_eq!(format!("{:?}", Borders::empty()), "NONE");
-        assert_eq!(format!("{:?}", Borders::NONE), "NONE");
-        assert_eq!(format!("{:?}", Borders::TOP), "TOP");
-        assert_eq!(format!("{:?}", Borders::BOTTOM), "BOTTOM");
-        assert_eq!(format!("{:?}", Borders::LEFT), "LEFT");
-        assert_eq!(format!("{:?}", Borders::RIGHT), "RIGHT");
-        assert_eq!(format!("{:?}", Borders::ALL), "ALL");
-        assert_eq!(format!("{:?}", Borders::all()), "ALL");
-
-        assert_eq!(
-            format!("{:?}", Borders::TOP | Borders::BOTTOM),
-            "TOP | BOTTOM"
-        );
-    }
-}
--- a/src/widgets/paragraph.rs
+++ b/src/widgets/paragraph.rs
@@ -1,15 +1,15 @@
-use unicode_width::UnicodeWidthStr;
-
 use crate::{
    buffer::Buffer,
    layout::{Alignment, Rect},
-    style::{Style, Styled},
+    style::Style,
    text::{StyledGrapheme, Text},
    widgets::{
        reflow::{LineComposer, LineTruncator, WordWrapper},
        Block, Widget,
    },
 };
+use std::iter;
+use unicode_width::UnicodeWidthStr;

 fn get_line_offset(line_width: u16, text_area_width: u16, alignment: Alignment) -> u16 {
    match alignment {
@@ -24,17 +24,17 @@ fn get_line_offset(line_width: u16, text_area_width: u16, alignment: Alignment)
 /// # Examples
 ///
 /// ```
-/// # use ratatui::text::{Text, Line, Span};
-/// # use ratatui::widgets::{Block, Borders, Paragraph, Wrap};
-/// # use ratatui::style::{Style, Color, Modifier};
-/// # use ratatui::layout::{Alignment};
+/// # use tui::text::{Text, Spans, Span};
+/// # use tui::widgets::{Block, Borders, Paragraph, Wrap};
+/// # use tui::style::{Style, Color, Modifier};
+/// # use tui::layout::{Alignment};
 /// let text = vec![
-///     Line::from(vec![
+///     Spans::from(vec![
 ///         Span::raw("First"),
 ///         Span::styled("line",Style::default().add_modifier(Modifier::ITALIC)),
 ///         Span::raw("."),
 ///     ]),
-///     Line::from(Span::styled("Second line", Style::default().fg(Color::Red))),
+///     Spans::from(Span::styled("Second line", Style::default().fg(Color::Red))),
 /// ];
 /// Paragraph::new(text)
 ///     .block(Block::default().title("Paragraph").borders(Borders::ALL))
@@ -63,8 +63,8 @@ pub struct Paragraph<'a> {
 /// ## Examples
 ///
 /// ```
-/// # use ratatui::widgets::{Paragraph, Wrap};
-/// # use ratatui::text::Text;
+/// # use tui::widgets::{Paragraph, Wrap};
+/// # use tui::text::Text;
 /// let bullet_points = Text::from(r#"Some indented points:
 ///     - First thing goes here and is long so that it wraps
 ///     - Here is another point that is long enough to wrap"#);
@@ -98,7 +98,7 @@ impl<'a> Paragraph<'a> {
    {
        Paragraph {
            block: None,
-            style: Style::default(),
+            style: Default::default(),
            wrap: None,
            text: text.into(),
            scroll: (0, 0),
@@ -149,34 +149,33 @@ impl<'a> Widget for Paragraph<'a> {
        }

        let style = self.style;
-        let styled = self.text.lines.iter().map(|line| {
-            (
-                line.spans
-                    .iter()
-                    .flat_map(|span| span.styled_graphemes(style)),
-                line.alignment.unwrap_or(self.alignment),
-            )
+        let mut styled = self.text.lines.iter().flat_map(|spans| {
+            spans
+                .0
+                .iter()
+                .flat_map(|span| span.styled_graphemes(style))
+                // Required given the way composers work but might be refactored out if we change
+                // composers to operate on lines instead of a stream of graphemes.
+                .chain(iter::once(StyledGrapheme {
+                    symbol: "\n",
+                    style: self.style,
+                }))
        });

        let mut line_composer: Box<dyn LineComposer> = if let Some(Wrap { trim }) = self.wrap {
-            Box::new(WordWrapper::new(styled, text_area.width, trim))
+            Box::new(WordWrapper::new(&mut styled, text_area.width, trim))
        } else {
-            let mut line_composer = Box::new(LineTruncator::new(styled, text_area.width));
-            line_composer.set_horizontal_offset(self.scroll.1);
+            let mut line_composer = Box::new(LineTruncator::new(&mut styled, text_area.width));
+            if let Alignment::Left = self.alignment {
+                line_composer.set_horizontal_offset(self.scroll.1);
+            }
            line_composer
        };
        let mut y = 0;
-        while let Some((current_line, current_line_width, current_line_alignment)) =
-            line_composer.next_line()
-        {
+        while let Some((current_line, current_line_width)) = line_composer.next_line() {
            if y >= self.scroll.0 {
-                let mut x =
-                    get_line_offset(current_line_width, text_area.width, current_line_alignment);
+                let mut x = get_line_offset(current_line_width, text_area.width, self.alignment);
                for StyledGrapheme { symbol, style } in current_line {
-                    let width = symbol.width();
-                    if width == 0 {
-                        continue;
-                    }
                    buf.get_mut(text_area.left() + x, text_area.top() + y - self.scroll.0)
                        .set_symbol(if symbol.is_empty() {
                            // If the symbol is empty, the last char which rendered last time will
@@ -186,7 +185,7 @@ impl<'a> Widget for Paragraph<'a> {
                            symbol
                        })
                        .set_style(*style);
-                    x += width as u16;
+                    x += symbol.width() as u16;
                }
            }
            y += 1;
@@ -196,510 +195,3 @@ impl<'a> Widget for Paragraph<'a> {
        }
    }
 }
-
-impl<'a> Styled for Paragraph<'a> {
-    type Item = Paragraph<'a>;
-
-    fn style(&self) -> Style {
-        self.style
-    }
-
-    fn set_style(self, style: Style) -> Self::Item {
-        self.style(style)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::{
-        backend::TestBackend,
-        style::Color,
-        text::{Line, Span},
-        widgets::Borders,
-        Terminal,
-    };
-
-    /// Tests the [`Paragraph`] widget against the expected [`Buffer`] by rendering it onto an equal
-    /// area and comparing the rendered and expected content.
-    /// This can be used for easy testing of varying configured paragraphs with the same expected
-    /// buffer or any other test case really.
-    fn test_case(paragraph: &Paragraph, expected: Buffer) {
-        let backend = TestBackend::new(expected.area.width, expected.area.height);
-        let mut terminal = Terminal::new(backend).unwrap();
-
-        terminal
-            .draw(|f| {
-                let size = f.size();
-                f.render_widget(paragraph.clone(), size);
-            })
-            .unwrap();
-
-        terminal.backend().assert_buffer(&expected);
-    }
-
-    #[test]
-    fn zero_width_char_at_end_of_line() {
-        let line = "foo\0";
-        let paragraphs = vec![
-            Paragraph::new(line),
-            Paragraph::new(line).wrap(Wrap { trim: false }),
-            Paragraph::new(line).wrap(Wrap { trim: true }),
-        ];
-
-        for paragraph in paragraphs {
-            test_case(&paragraph, Buffer::with_lines(vec!["foo"]));
-            test_case(&paragraph, Buffer::with_lines(vec!["foo   "]));
-            test_case(&paragraph, Buffer::with_lines(vec!["foo   ", "      "]));
-            test_case(&paragraph, Buffer::with_lines(vec!["foo", "   "]));
-        }
-    }
-
-    #[test]
-    fn test_render_empty_paragraph() {
-        let paragraphs = vec![
-            Paragraph::new(""),
-            Paragraph::new("").wrap(Wrap { trim: false }),
-            Paragraph::new("").wrap(Wrap { trim: true }),
-        ];
-
-        for paragraph in paragraphs {
-            test_case(&paragraph, Buffer::with_lines(vec![" "]));
-            test_case(&paragraph, Buffer::with_lines(vec!["          "]));
-            test_case(&paragraph, Buffer::with_lines(vec!["     "; 10]));
-            test_case(&paragraph, Buffer::with_lines(vec![" ", " "]));
-        }
-    }
-
-    #[test]
-    fn test_render_single_line_paragraph() {
-        let text = "Hello, world!";
-        let truncated_paragraph = Paragraph::new(text);
-        let wrapped_paragraph = Paragraph::new(text).wrap(Wrap { trim: false });
-        let trimmed_paragraph = Paragraph::new(text).wrap(Wrap { trim: true });
-
-        let paragraphs = vec![&truncated_paragraph, &wrapped_paragraph, &trimmed_paragraph];
-
-        for paragraph in paragraphs {
-            test_case(paragraph, Buffer::with_lines(vec!["Hello, world!  "]));
-            test_case(paragraph, Buffer::with_lines(vec!["Hello, world!"]));
-            test_case(
-                paragraph,
-                Buffer::with_lines(vec!["Hello, world!  ", "               "]),
-            );
-            test_case(
-                paragraph,
-                Buffer::with_lines(vec!["Hello, world!", "             "]),
-            );
-        }
-    }
-
-    #[test]
-    fn test_render_multi_line_paragraph() {
-        let text = "This is a\nmultiline\nparagraph.";
-
-        let paragraphs = vec![
-            Paragraph::new(text),
-            Paragraph::new(text).wrap(Wrap { trim: false }),
-            Paragraph::new(text).wrap(Wrap { trim: true }),
-        ];
-
-        for paragraph in paragraphs {
-            test_case(
-                &paragraph,
-                Buffer::with_lines(vec!["This is a ", "multiline ", "paragraph."]),
-            );
-            test_case(
-                &paragraph,
-                Buffer::with_lines(vec![
-                    "This is a      ",
-                    "multiline      ",
-                    "paragraph.     ",
-                ]),
-            );
-            test_case(
-                &paragraph,
-                Buffer::with_lines(vec![
-                    "This is a      ",
-                    "multiline      ",
-                    "paragraph.     ",
-                    "               ",
-                    "               ",
-                ]),
-            );
-        }
-    }
-
-    #[test]
-    fn test_render_paragraph_with_block() {
-        // We use the slightly unconventional "worlds" instead of "world" here to make sure when we
-        // can truncate this without triggering the typos linter.
-        let text = "Hello, worlds!";
-        let truncated_paragraph =
-            Paragraph::new(text).block(Block::default().title("Title").borders(Borders::ALL));
-        let wrapped_paragraph = truncated_paragraph.clone().wrap(Wrap { trim: false });
-        let trimmed_paragraph = truncated_paragraph.clone().wrap(Wrap { trim: true });
-
-        let paragraphs = vec![&truncated_paragraph, &wrapped_paragraph, &trimmed_paragraph];
-
-        for paragraph in paragraphs {
-            test_case(
-                paragraph,
-                Buffer::with_lines(vec![
-                    "┌Title─────────┐",
-                    "│Hello, worlds!│",
-                    "└──────────────┘",
-                ]),
-            );
-            test_case(
-                paragraph,
-                Buffer::with_lines(vec![
-                    "┌Title───────────┐",
-                    "│Hello, worlds!  │",
-                    "└────────────────┘",
-                ]),
-            );
-            test_case(
-                paragraph,
-                Buffer::with_lines(vec![
-                    "┌Title────────────┐",
-                    "│Hello, worlds!   │",
-                    "│                 │",
-                    "└─────────────────┘",
-                ]),
-            );
-        }
-
-        test_case(
-            &truncated_paragraph,
-            Buffer::with_lines(vec![
-                "┌Title───────┐",
-                "│Hello, world│",
-                "│            │",
-                "└────────────┘",
-            ]),
-        );
-        test_case(
-            &wrapped_paragraph,
-            Buffer::with_lines(vec![
-                "┌Title──────┐",
-                "│Hello,     │",
-                "│worlds!    │",
-                "└───────────┘",
-            ]),
-        );
-        test_case(
-            &trimmed_paragraph,
-            Buffer::with_lines(vec![
-                "┌Title──────┐",
-                "│Hello,     │",
-                "│worlds!    │",
-                "└───────────┘",
-            ]),
-        );
-    }
-
-    #[test]
-    fn test_render_paragraph_with_word_wrap() {
-        let text = "This is a long line of text that should wrap      and contains a superultramegagigalong word.";
-        let wrapped_paragraph = Paragraph::new(text).wrap(Wrap { trim: false });
-        let trimmed_paragraph = Paragraph::new(text).wrap(Wrap { trim: true });
-
-        test_case(
-            &wrapped_paragraph,
-            Buffer::with_lines(vec![
-                "This is a long line",
-                "of text that should",
-                "wrap      and      ",
-                "contains a         ",
-                "superultramegagigal",
-                "ong word.          ",
-            ]),
-        );
-        test_case(
-            &wrapped_paragraph,
-            Buffer::with_lines(vec![
-                "This is a   ",
-                "long line of",
-                "text that   ",
-                "should wrap ",
-                "    and     ",
-                "contains a  ",
-                "superultrame",
-                "gagigalong  ",
-                "word.       ",
-            ]),
-        );
-
-        test_case(
-            &trimmed_paragraph,
-            Buffer::with_lines(vec![
-                "This is a long line",
-                "of text that should",
-                "wrap      and      ",
-                "contains a         ",
-                "superultramegagigal",
-                "ong word.          ",
-            ]),
-        );
-        test_case(
-            &trimmed_paragraph,
-            Buffer::with_lines(vec![
-                "This is a   ",
-                "long line of",
-                "text that   ",
-                "should wrap ",
-                "and contains",
-                "a           ",
-                "superultrame",
-                "gagigalong  ",
-                "word.       ",
-            ]),
-        );
-    }
-
-    #[test]
-    fn test_render_paragraph_with_line_truncation() {
-        let text = "This is a long line of text that should be truncated.";
-        let truncated_paragraph = Paragraph::new(text);
-
-        test_case(
-            &truncated_paragraph,
-            Buffer::with_lines(vec!["This is a long line of"]),
-        );
-        test_case(
-            &truncated_paragraph,
-            Buffer::with_lines(vec!["This is a long line of te"]),
-        );
-        test_case(
-            &truncated_paragraph,
-            Buffer::with_lines(vec!["This is a long line of "]),
-        );
-        test_case(
-            &truncated_paragraph.clone().scroll((0, 2)),
-            Buffer::with_lines(vec!["is is a long line of te"]),
-        );
-    }
-
-    #[test]
-    fn test_render_paragraph_with_left_alignment() {
-        let text = "Hello, world!";
-        let truncated_paragraph = Paragraph::new(text).alignment(Alignment::Left);
-        let wrapped_paragraph = truncated_paragraph.clone().wrap(Wrap { trim: false });
-        let trimmed_paragraph = truncated_paragraph.clone().wrap(Wrap { trim: true });
-
-        let paragraphs = vec![&truncated_paragraph, &wrapped_paragraph, &trimmed_paragraph];
-
-        for paragraph in paragraphs {
-            test_case(paragraph, Buffer::with_lines(vec!["Hello, world!  "]));
-            test_case(paragraph, Buffer::with_lines(vec!["Hello, world!"]));
-        }
-
-        test_case(&truncated_paragraph, Buffer::with_lines(vec!["Hello, wor"]));
-        test_case(
-            &wrapped_paragraph,
-            Buffer::with_lines(vec!["Hello,    ", "world!    "]),
-        );
-        test_case(
-            &trimmed_paragraph,
-            Buffer::with_lines(vec!["Hello,    ", "world!    "]),
-        );
-    }
-
-    #[test]
-    fn test_render_paragraph_with_center_alignment() {
-        let text = "Hello, world!";
-        let truncated_paragraph = Paragraph::new(text).alignment(Alignment::Center);
-        let wrapped_paragraph = truncated_paragraph.clone().wrap(Wrap { trim: false });
-        let trimmed_paragraph = truncated_paragraph.clone().wrap(Wrap { trim: true });
-
-        let paragraphs = vec![&truncated_paragraph, &wrapped_paragraph, &trimmed_paragraph];
-
-        for paragraph in paragraphs {
-            test_case(paragraph, Buffer::with_lines(vec![" Hello, world! "]));
-            test_case(paragraph, Buffer::with_lines(vec!["  Hello, world! "]));
-            test_case(paragraph, Buffer::with_lines(vec!["  Hello, world!  "]));
-            test_case(paragraph, Buffer::with_lines(vec!["Hello, world!"]));
-        }
-
-        test_case(&truncated_paragraph, Buffer::with_lines(vec!["Hello, wor"]));
-        test_case(
-            &wrapped_paragraph,
-            Buffer::with_lines(vec!["  Hello,  ", "  world!  "]),
-        );
-        test_case(
-            &trimmed_paragraph,
-            Buffer::with_lines(vec!["  Hello,  ", "  world!  "]),
-        );
-    }
-
-    #[test]
-    fn test_render_paragraph_with_right_alignment() {
-        let text = "Hello, world!";
-        let truncated_paragraph = Paragraph::new(text).alignment(Alignment::Right);
-        let wrapped_paragraph = truncated_paragraph.clone().wrap(Wrap { trim: false });
-        let trimmed_paragraph = truncated_paragraph.clone().wrap(Wrap { trim: true });
-
-        let paragraphs = vec![&truncated_paragraph, &wrapped_paragraph, &trimmed_paragraph];
-
-        for paragraph in paragraphs {
-            test_case(paragraph, Buffer::with_lines(vec!["  Hello, world!"]));
-            test_case(paragraph, Buffer::with_lines(vec!["Hello, world!"]));
-        }
-
-        test_case(&truncated_paragraph, Buffer::with_lines(vec!["Hello, wor"]));
-        test_case(
-            &wrapped_paragraph,
-            Buffer::with_lines(vec!["    Hello,", "    world!"]),
-        );
-        test_case(
-            &trimmed_paragraph,
-            Buffer::with_lines(vec!["    Hello,", "    world!"]),
-        );
-    }
-
-    #[test]
-    fn test_render_paragraph_with_scroll_offset() {
-        let text = "This is a\ncool\nmultiline\nparagraph.";
-        let truncated_paragraph = Paragraph::new(text).scroll((2, 0));
-        let wrapped_paragraph = truncated_paragraph.clone().wrap(Wrap { trim: false });
-        let trimmed_paragraph = truncated_paragraph.clone().wrap(Wrap { trim: true });
-
-        let paragraphs = vec![&truncated_paragraph, &wrapped_paragraph, &trimmed_paragraph];
-
-        for paragraph in paragraphs {
-            test_case(
-                paragraph,
-                Buffer::with_lines(vec!["multiline   ", "paragraph.  ", "            "]),
-            );
-            test_case(paragraph, Buffer::with_lines(vec!["multiline   "]));
-        }
-
-        test_case(
-            &truncated_paragraph.clone().scroll((2, 4)),
-            Buffer::with_lines(vec!["iline   ", "graph.  "]),
-        );
-        test_case(
-            &wrapped_paragraph,
-            Buffer::with_lines(vec!["cool   ", "multili", "ne     "]),
-        );
-    }
-
-    #[test]
-    fn test_render_paragraph_with_zero_width_area() {
-        let text = "Hello, world!";
-
-        let paragraphs = vec![
-            Paragraph::new(text),
-            Paragraph::new(text).wrap(Wrap { trim: false }),
-            Paragraph::new(text).wrap(Wrap { trim: true }),
-        ];
-
-        let area = Rect::new(0, 0, 0, 3);
-        for paragraph in paragraphs {
-            test_case(&paragraph, Buffer::empty(area));
-            test_case(&paragraph.clone().scroll((2, 4)), Buffer::empty(area));
-        }
-    }
-
-    #[test]
-    fn test_render_paragraph_with_zero_height_area() {
-        let text = "Hello, world!";
-
-        let paragraphs = vec![
-            Paragraph::new(text),
-            Paragraph::new(text).wrap(Wrap { trim: false }),
-            Paragraph::new(text).wrap(Wrap { trim: true }),
-        ];
-
-        let area = Rect::new(0, 0, 10, 0);
-        for paragraph in paragraphs {
-            test_case(&paragraph, Buffer::empty(area));
-            test_case(&paragraph.clone().scroll((2, 4)), Buffer::empty(area));
-        }
-    }
-
-    #[test]
-    fn test_render_paragraph_with_styled_text() {
-        let text = Line::from(vec![
-            Span::styled("Hello, ", Style::default().fg(Color::Red)),
-            Span::styled("world!", Style::default().fg(Color::Blue)),
-        ]);
-
-        let paragraphs = vec![
-            Paragraph::new(text.clone()),
-            Paragraph::new(text.clone()).wrap(Wrap { trim: false }),
-            Paragraph::new(text.clone()).wrap(Wrap { trim: true }),
-        ];
-
-        let mut expected_buffer = Buffer::with_lines(vec!["Hello, world!"]);
-        expected_buffer.set_style(
-            Rect::new(0, 0, 7, 1),
-            Style::default().fg(Color::Red).bg(Color::Green),
-        );
-        expected_buffer.set_style(
-            Rect::new(7, 0, 6, 1),
-            Style::default().fg(Color::Blue).bg(Color::Green),
-        );
-        for paragraph in paragraphs {
-            test_case(
-                &paragraph.style(Style::default().bg(Color::Green)),
-                expected_buffer.clone(),
-            );
-        }
-    }
-
-    #[test]
-    fn test_render_paragraph_with_special_characters() {
-        let text = "Hello, <world>!";
-        let paragraphs = vec![
-            Paragraph::new(text),
-            Paragraph::new(text).wrap(Wrap { trim: false }),
-            Paragraph::new(text).wrap(Wrap { trim: true }),
-        ];
-
-        for paragraph in paragraphs {
-            test_case(&paragraph, Buffer::with_lines(vec!["Hello, <world>!"]));
-            test_case(&paragraph, Buffer::with_lines(vec!["Hello, <world>!     "]));
-            test_case(
-                &paragraph,
-                Buffer::with_lines(vec!["Hello, <world>!     ", "                    "]),
-            );
-            test_case(
-                &paragraph,
-                Buffer::with_lines(vec!["Hello, <world>!", "               "]),
-            );
-        }
-    }
-
-    #[test]
-    fn test_render_paragraph_with_unicode_characters() {
-        let text = "こんにちは, 世界! 😃";
-        let truncated_paragraph = Paragraph::new(text);
-        let wrapped_paragraph = Paragraph::new(text).wrap(Wrap { trim: false });
-        let trimmed_paragraph = Paragraph::new(text).wrap(Wrap { trim: true });
-
-        let paragraphs = vec![&truncated_paragraph, &wrapped_paragraph, &trimmed_paragraph];
-
-        for paragraph in paragraphs {
-            test_case(paragraph, Buffer::with_lines(vec!["こんにちは, 世界! 😃"]));
-            test_case(
-                paragraph,
-                Buffer::with_lines(vec!["こんにちは, 世界! 😃     "]),
-            );
-        }
-
-        test_case(
-            &truncated_paragraph,
-            Buffer::with_lines(vec!["こんにちは, 世 "]),
-        );
-        test_case(
-            &wrapped_paragraph,
-            Buffer::with_lines(vec!["こんにちは,    ", "世界! 😃      "]),
-        );
-        test_case(
-            &trimmed_paragraph,
-            Buffer::with_lines(vec!["こんにちは,    ", "世界! 😃      "]),
-        );
-    }
-}
--- a/src/widgets/reflow.rs
+++ b/src/widgets/reflow.rs
@@ -1,236 +1,143 @@
-use std::{collections::VecDeque, vec::IntoIter};
-
+use crate::text::StyledGrapheme;
 use unicode_segmentation::UnicodeSegmentation;
 use unicode_width::UnicodeWidthStr;

-use crate::{layout::Alignment, text::StyledGrapheme};
-
 const NBSP: &str = "\u{00a0}";

 /// A state machine to pack styled symbols into lines.
 /// Cannot implement it as Iterator since it yields slices of the internal buffer (need streaming
 /// iterators for that).
 pub trait LineComposer<'a> {
-    fn next_line(&mut self) -> Option<(&[StyledGrapheme<'a>], u16, Alignment)>;
+    fn next_line(&mut self) -> Option<(&[StyledGrapheme<'a>], u16)>;
 }

 /// A state machine that wraps lines on word boundaries.
-pub struct WordWrapper<'a, O, I>
-where
-    // Outer iterator providing the individual lines
-    O: Iterator<Item = (I, Alignment)>,
-    // Inner iterator providing the styled symbols of a line Each line consists of an alignment and
-    // a series of symbols
-    I: Iterator<Item = StyledGrapheme<'a>>,
-{
-    /// The given, unprocessed lines
-    input_lines: O,
+pub struct WordWrapper<'a, 'b> {
+    symbols: &'b mut dyn Iterator<Item = StyledGrapheme<'a>>,
    max_line_width: u16,
-    wrapped_lines: Option<IntoIter<Vec<StyledGrapheme<'a>>>>,
-    current_alignment: Alignment,
    current_line: Vec<StyledGrapheme<'a>>,
+    next_line: Vec<StyledGrapheme<'a>>,
    /// Removes the leading whitespace from lines
    trim: bool,
 }

-impl<'a, O, I> WordWrapper<'a, O, I>
-where
-    O: Iterator<Item = (I, Alignment)>,
-    I: Iterator<Item = StyledGrapheme<'a>>,
-{
-    pub fn new(lines: O, max_line_width: u16, trim: bool) -> WordWrapper<'a, O, I> {
+impl<'a, 'b> WordWrapper<'a, 'b> {
+    pub fn new(
+        symbols: &'b mut dyn Iterator<Item = StyledGrapheme<'a>>,
+        max_line_width: u16,
+        trim: bool,
+    ) -> WordWrapper<'a, 'b> {
        WordWrapper {
-            input_lines: lines,
+            symbols,
            max_line_width,
-            wrapped_lines: None,
-            current_alignment: Alignment::Left,
            current_line: vec![],
+            next_line: vec![],
            trim,
        }
    }
 }

-impl<'a, O, I> LineComposer<'a> for WordWrapper<'a, O, I>
-where
-    O: Iterator<Item = (I, Alignment)>,
-    I: Iterator<Item = StyledGrapheme<'a>>,
-{
-    fn next_line(&mut self) -> Option<(&[StyledGrapheme<'a>], u16, Alignment)> {
+impl<'a, 'b> LineComposer<'a> for WordWrapper<'a, 'b> {
+    fn next_line(&mut self) -> Option<(&[StyledGrapheme<'a>], u16)> {
        if self.max_line_width == 0 {
            return None;
        }
+        std::mem::swap(&mut self.current_line, &mut self.next_line);
+        self.next_line.truncate(0);

-        let mut current_line: Option<Vec<StyledGrapheme<'a>>> = None;
-        let mut line_width: u16 = 0;
+        let mut current_line_width = self
+            .current_line
+            .iter()
+            .map(|StyledGrapheme { symbol, .. }| symbol.width() as u16)
+            .sum();

-        // Try to repeatedly retrieve next line
-        while current_line.is_none() {
-            // Retrieve next preprocessed wrapped line
-            if let Some(line_iterator) = &mut self.wrapped_lines {
-                if let Some(line) = line_iterator.next() {
-                    line_width = line
-                        .iter()
-                        .map(|grapheme| grapheme.symbol.width())
-                        .sum::<usize>() as u16;
-                    current_line = Some(line);
-                }
+        let mut symbols_to_last_word_end: usize = 0;
+        let mut width_to_last_word_end: u16 = 0;
+        let mut prev_whitespace = false;
+        let mut symbols_exhausted = true;
+        for StyledGrapheme { symbol, style } in &mut self.symbols {
+            symbols_exhausted = false;
+            let symbol_whitespace = symbol.chars().all(&char::is_whitespace) && symbol != NBSP;
+
+            // Ignore characters wider that the total max width.
+            if symbol.width() as u16 > self.max_line_width
+                // Skip leading whitespace when trim is enabled.
+                || self.trim && symbol_whitespace && symbol != "\n" && current_line_width == 0
+            {
+                continue;
            }

-            // When no more preprocessed wrapped lines
-            if current_line.is_none() {
-                // Try to calculate next wrapped lines based on current whole line
-                if let Some((line_symbols, line_alignment)) = &mut self.input_lines.next() {
-                    // Save the whole line's alignment
-                    self.current_alignment = *line_alignment;
-                    let mut wrapped_lines = vec![]; // Saves the wrapped lines
-                                                    // Saves the unfinished wrapped line
-                    let (mut current_line, mut current_line_width) = (vec![], 0);
-                    // Saves the partially processed word
-                    let (mut unfinished_word, mut word_width) = (vec![], 0);
-                    // Saves the whitespaces of the partially unfinished word
-                    let (mut unfinished_whitespaces, mut whitespace_width) =
-                        (VecDeque::<StyledGrapheme>::new(), 0);
+            // Break on newline and discard it.
+            if symbol == "\n" {
+                if prev_whitespace {
+                    current_line_width = width_to_last_word_end;
+                    self.current_line.truncate(symbols_to_last_word_end);
+                }
+                break;
+            }

-                    let mut has_seen_non_whitespace = false;
-                    for StyledGrapheme { symbol, style } in line_symbols {
-                        let symbol_whitespace =
-                            symbol.chars().all(&char::is_whitespace) && symbol != NBSP;
-                        let symbol_width = symbol.width() as u16;
-                        // Ignore characters wider than the total max width
-                        if symbol_width > self.max_line_width {
-                            continue;
-                        }
+            // Mark the previous symbol as word end.
+            if symbol_whitespace && !prev_whitespace {
+                symbols_to_last_word_end = self.current_line.len();
+                width_to_last_word_end = current_line_width;
+            }

-                        // Append finished word to current line
-                        if has_seen_non_whitespace && symbol_whitespace
-                            // Append if trimmed (whitespaces removed) word would overflow
-                            || word_width + symbol_width > self.max_line_width && current_line.is_empty() && self.trim
-                            // Append if removed whitespace would overflow -> reset whitespace counting to prevent overflow
-                            || whitespace_width + symbol_width > self.max_line_width && current_line.is_empty() && self.trim
-                            // Append if complete word would overflow
-                            || word_width + whitespace_width + symbol_width > self.max_line_width && current_line.is_empty() && !self.trim
-                        {
-                            if !current_line.is_empty() || !self.trim {
-                                // Also append whitespaces if not trimming or current line is not
-                                // empty
-                                current_line.extend(
-                                    std::mem::take(&mut unfinished_whitespaces).into_iter(),
-                                );
-                                current_line_width += whitespace_width;
-                            }
-                            // Append trimmed word
-                            current_line.append(&mut unfinished_word);
-                            current_line_width += word_width;
+            self.current_line.push(StyledGrapheme { symbol, style });
+            current_line_width += symbol.width() as u16;

-                            // Clear whitespace buffer
-                            unfinished_whitespaces.clear();
-                            whitespace_width = 0;
-                            word_width = 0;
-                        }
-
-                        // Append the unfinished wrapped line to wrapped lines if it is as wide as
-                        // max line width
-                        if current_line_width >= self.max_line_width
-                            // or if it would be too long with the current partially processed word added
-                            || current_line_width + whitespace_width + word_width >= self.max_line_width && symbol_width > 0
-                        {
-                            let mut remaining_width =
-                                (self.max_line_width as i32 - current_line_width as i32).max(0)
-                                    as u16;
-                            wrapped_lines.push(std::mem::take(&mut current_line));
-                            current_line_width = 0;
-
-                            // Remove all whitespaces till end of just appended wrapped line + next
-                            // whitespace
-                            let mut first_whitespace = unfinished_whitespaces.pop_front();
-                            while let Some(grapheme) = first_whitespace.as_ref() {
-                                let symbol_width = grapheme.symbol.width() as u16;
-                                whitespace_width -= symbol_width;
-
-                                if symbol_width > remaining_width {
-                                    break;
-                                }
-                                remaining_width -= symbol_width;
-                                first_whitespace = unfinished_whitespaces.pop_front();
-                            }
-                            // In case all whitespaces have been exhausted
-                            if symbol_whitespace && first_whitespace.is_none() {
-                                // Prevent first whitespace to count towards next word
-                                continue;
-                            }
-                        }
-
-                        // Append symbol to unfinished, partially processed word
-                        if symbol_whitespace {
-                            whitespace_width += symbol_width;
-                            unfinished_whitespaces.push_back(StyledGrapheme { symbol, style });
-                        } else {
-                            word_width += symbol_width;
-                            unfinished_word.push(StyledGrapheme { symbol, style });
-                        }
-
-                        has_seen_non_whitespace = !symbol_whitespace;
-                    }
-
-                    // Append remaining text parts
-                    if !unfinished_word.is_empty() || !unfinished_whitespaces.is_empty() {
-                        if current_line.is_empty() && unfinished_word.is_empty() {
-                            wrapped_lines.push(vec![]);
-                        } else if !self.trim || !current_line.is_empty() {
-                            current_line.extend(unfinished_whitespaces.into_iter());
-                        }
-                        current_line.append(&mut unfinished_word);
-                    }
-                    if !current_line.is_empty() {
-                        wrapped_lines.push(current_line);
-                    }
-                    if wrapped_lines.is_empty() {
-                        // Append empty line if there was nothing to wrap in the first place
-                        wrapped_lines.push(vec![]);
-                    }
-
-                    self.wrapped_lines = Some(wrapped_lines.into_iter());
+            if current_line_width > self.max_line_width {
+                // If there was no word break in the text, wrap at the end of the line.
+                let (truncate_at, truncated_width) = if symbols_to_last_word_end != 0 {
+                    (symbols_to_last_word_end, width_to_last_word_end)
                } else {
-                    // No more whole lines available -> stop repeatedly retrieving next wrapped line
-                    break;
+                    (self.current_line.len() - 1, self.max_line_width)
+                };
+
+                // Push the remainder to the next line but strip leading whitespace:
+                {
+                    let remainder = &self.current_line[truncate_at..];
+                    if let Some(remainder_nonwhite) =
+                        remainder.iter().position(|StyledGrapheme { symbol, .. }| {
+                            !symbol.chars().all(&char::is_whitespace)
+                        })
+                    {
+                        self.next_line
+                            .extend_from_slice(&remainder[remainder_nonwhite..]);
+                    }
                }
+                self.current_line.truncate(truncate_at);
+                current_line_width = truncated_width;
+                break;
            }
+
+            prev_whitespace = symbol_whitespace;
        }

-        if let Some(line) = current_line {
-            self.current_line = line;
-            Some((&self.current_line[..], line_width, self.current_alignment))
-        } else {
+        // Even if the iterator is exhausted, pass the previous remainder.
+        if symbols_exhausted && self.current_line.is_empty() {
            None
+        } else {
+            Some((&self.current_line[..], current_line_width))
        }
    }
 }

 /// A state machine that truncates overhanging lines.
-pub struct LineTruncator<'a, O, I>
-where
-    // Outer iterator providing the individual lines
-    O: Iterator<Item = (I, Alignment)>,
-    // Inner iterator providing the styled symbols of a line Each line consists of an alignment and
-    // a series of symbols
-    I: Iterator<Item = StyledGrapheme<'a>>,
-{
-    /// The given, unprocessed lines
-    input_lines: O,
+pub struct LineTruncator<'a, 'b> {
+    symbols: &'b mut dyn Iterator<Item = StyledGrapheme<'a>>,
    max_line_width: u16,
    current_line: Vec<StyledGrapheme<'a>>,
-    /// Record the offset to skip render
+    /// Record the offet to skip render
    horizontal_offset: u16,
 }

-impl<'a, O, I> LineTruncator<'a, O, I>
-where
-    O: Iterator<Item = (I, Alignment)>,
-    I: Iterator<Item = StyledGrapheme<'a>>,
-{
-    pub fn new(lines: O, max_line_width: u16) -> LineTruncator<'a, O, I> {
+impl<'a, 'b> LineTruncator<'a, 'b> {
+    pub fn new(
+        symbols: &'b mut dyn Iterator<Item = StyledGrapheme<'a>>,
+        max_line_width: u16,
+    ) -> LineTruncator<'a, 'b> {
        LineTruncator {
-            input_lines: lines,
+            symbols,
            max_line_width,
            horizontal_offset: 0,
            current_line: vec![],
@@ -242,12 +149,8 @@ where
    }
 }

-impl<'a, O, I> LineComposer<'a> for LineTruncator<'a, O, I>
-where
-    O: Iterator<Item = (I, Alignment)>,
-    I: Iterator<Item = StyledGrapheme<'a>>,
-{
-    fn next_line(&mut self) -> Option<(&[StyledGrapheme<'a>], u16, Alignment)> {
+impl<'a, 'b> LineComposer<'a> for LineTruncator<'a, 'b> {
+    fn next_line(&mut self) -> Option<(&[StyledGrapheme<'a>], u16)> {
        if self.max_line_width == 0 {
            return None;
        }
@@ -255,50 +158,57 @@ where
        self.current_line.truncate(0);
        let mut current_line_width = 0;

-        let mut lines_exhausted = true;
+        let mut skip_rest = false;
+        let mut symbols_exhausted = true;
        let mut horizontal_offset = self.horizontal_offset as usize;
-        let mut current_alignment = Alignment::Left;
-        if let Some((current_line, alignment)) = &mut self.input_lines.next() {
-            lines_exhausted = false;
-            current_alignment = *alignment;
+        for StyledGrapheme { symbol, style } in &mut self.symbols {
+            symbols_exhausted = false;

-            for StyledGrapheme { symbol, style } in current_line {
-                // Ignore characters wider that the total max width.
-                if symbol.width() as u16 > self.max_line_width {
-                    continue;
+            // Ignore characters wider that the total max width.
+            if symbol.width() as u16 > self.max_line_width {
+                continue;
+            }
+
+            // Break on newline and discard it.
+            if symbol == "\n" {
+                break;
+            }
+
+            if current_line_width + symbol.width() as u16 > self.max_line_width {
+                // Exhaust the remainder of the line.
+                skip_rest = true;
+                break;
+            }
+
+            let symbol = if horizontal_offset == 0 {
+                symbol
+            } else {
+                let w = symbol.width();
+                if w > horizontal_offset {
+                    let t = trim_offset(symbol, horizontal_offset);
+                    horizontal_offset = 0;
+                    t
+                } else {
+                    horizontal_offset -= w;
+                    ""
                }
+            };
+            current_line_width += symbol.width() as u16;
+            self.current_line.push(StyledGrapheme { symbol, style });
+        }

-                if current_line_width + symbol.width() as u16 > self.max_line_width {
-                    // Truncate line
+        if skip_rest {
+            for StyledGrapheme { symbol, .. } in &mut self.symbols {
+                if symbol == "\n" {
                    break;
                }
-
-                let symbol = if horizontal_offset == 0 || Alignment::Left != *alignment {
-                    symbol
-                } else {
-                    let w = symbol.width();
-                    if w > horizontal_offset {
-                        let t = trim_offset(symbol, horizontal_offset);
-                        horizontal_offset = 0;
-                        t
-                    } else {
-                        horizontal_offset -= w;
-                        ""
-                    }
-                };
-                current_line_width += symbol.width() as u16;
-                self.current_line.push(StyledGrapheme { symbol, style });
            }
        }

-        if lines_exhausted {
+        if symbols_exhausted && self.current_line.is_empty() {
            None
        } else {
-            Some((
-                &self.current_line[..],
-                current_line_width,
-                current_alignment,
-            ))
+            Some((&self.current_line[..], current_line_width))
        }
    }
 }
@@ -321,44 +231,27 @@ fn trim_offset(src: &str, mut offset: usize) -> &str {

 #[cfg(test)]
 mod test {
-    use unicode_segmentation::UnicodeSegmentation;
-
    use super::*;
-    use crate::{
-        style::Style,
-        text::{Line, Text},
-    };
+    use unicode_segmentation::UnicodeSegmentation;

    enum Composer {
        WordWrapper { trim: bool },
        LineTruncator,
    }

-    fn run_composer<'a>(
-        which: Composer,
-        text: impl Into<Text<'a>>,
-        text_area_width: u16,
-    ) -> (Vec<String>, Vec<u16>, Vec<Alignment>) {
-        let text = text.into();
-        let styled_lines = text.lines.iter().map(|line| {
-            (
-                line.spans
-                    .iter()
-                    .flat_map(|span| span.styled_graphemes(Style::default())),
-                line.alignment.unwrap_or(Alignment::Left),
-            )
-        });
-
+    fn run_composer(which: Composer, text: &str, text_area_width: u16) -> (Vec<String>, Vec<u16>) {
+        let style = Default::default();
+        let mut styled =
+            UnicodeSegmentation::graphemes(text, true).map(|g| StyledGrapheme { symbol: g, style });
        let mut composer: Box<dyn LineComposer> = match which {
            Composer::WordWrapper { trim } => {
-                Box::new(WordWrapper::new(styled_lines, text_area_width, trim))
+                Box::new(WordWrapper::new(&mut styled, text_area_width, trim))
            }
-            Composer::LineTruncator => Box::new(LineTruncator::new(styled_lines, text_area_width)),
+            Composer::LineTruncator => Box::new(LineTruncator::new(&mut styled, text_area_width)),
        };
        let mut lines = vec![];
        let mut widths = vec![];
-        let mut alignments = vec![];
-        while let Some((styled, width, alignment)) = composer.next_line() {
+        while let Some((styled, width)) = composer.next_line() {
            let line = styled
                .iter()
                .map(|StyledGrapheme { symbol, .. }| *symbol)
@@ -366,9 +259,8 @@ mod test {
            assert!(width <= text_area_width);
            lines.push(line);
            widths.push(width);
-            alignments.push(alignment);
        }
-        (lines, widths, alignments)
+        (lines, widths)
    }

    #[test]
@@ -376,13 +268,9 @@ mod test {
        let width = 40;
        for i in 1..width {
            let text = "a".repeat(i);
-            let (word_wrapper, _, _) = run_composer(
-                Composer::WordWrapper { trim: true },
-                &text[..],
-                width as u16,
-            );
-            let (line_truncator, _, _) =
-                run_composer(Composer::LineTruncator, &text[..], width as u16);
+            let (word_wrapper, _) =
+                run_composer(Composer::WordWrapper { trim: true }, &text, width as u16);
+            let (line_truncator, _) = run_composer(Composer::LineTruncator, &text, width as u16);
            let expected = vec![text];
            assert_eq!(word_wrapper, expected);
            assert_eq!(line_truncator, expected);
@@ -394,8 +282,8 @@ mod test {
        let width = 20;
        let text =
            "abcdefg\nhijklmno\npabcdefg\nhijklmn\nopabcdefghijk\nlmnopabcd\n\n\nefghijklmno";
-        let (word_wrapper, _, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
-        let (line_truncator, _, _) = run_composer(Composer::LineTruncator, text, width);
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);

        let wrapped: Vec<&str> = text.split('\n').collect();
        assert_eq!(word_wrapper, wrapped);
@@ -406,9 +294,9 @@ mod test {
    fn line_composer_long_word() {
        let width = 20;
        let text = "abcdefghijklmnopabcdefghijklmnopabcdefghijklmnopabcdefghijklmno";
-        let (word_wrapper, _, _) =
+        let (word_wrapper, _) =
            run_composer(Composer::WordWrapper { trim: true }, text, width as u16);
-        let (line_truncator, _, _) = run_composer(Composer::LineTruncator, text, width as u16);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width as u16);

        let wrapped = vec![
            &text[..width],
@@ -432,14 +320,14 @@ mod test {
        let text_multi_space =
            "abcd efghij    klmnopabcd efgh     ijklmnopabcdefg hijkl mnopab c d e f g h i j k l \
             m n o";
-        let (word_wrapper_single_space, _, _) =
+        let (word_wrapper_single_space, _) =
            run_composer(Composer::WordWrapper { trim: true }, text, width as u16);
-        let (word_wrapper_multi_space, _, _) = run_composer(
+        let (word_wrapper_multi_space, _) = run_composer(
            Composer::WordWrapper { trim: true },
            text_multi_space,
            width as u16,
        );
-        let (line_truncator, _, _) = run_composer(Composer::LineTruncator, text, width as u16);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width as u16);

        let word_wrapped = vec![
            "abcd efghij",
@@ -458,8 +346,8 @@ mod test {
    fn line_composer_zero_width() {
        let width = 0;
        let text = "abcd efghij klmnopabcd efgh ijklmnopabcdefg hijkl mnopab ";
-        let (word_wrapper, _, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
-        let (line_truncator, _, _) = run_composer(Composer::LineTruncator, text, width);
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);

        let expected: Vec<&str> = Vec::new();
        assert_eq!(word_wrapper, expected);
@@ -470,8 +358,8 @@ mod test {
    fn line_composer_max_line_width_of_1() {
        let width = 1;
        let text = "abcd efghij klmnopabcd efgh ijklmnopabcdefg hijkl mnopab ";
-        let (word_wrapper, _, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
-        let (line_truncator, _, _) = run_composer(Composer::LineTruncator, text, width);
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);

        let expected: Vec<&str> = UnicodeSegmentation::graphemes(text, true)
            .filter(|g| g.chars().any(|c| !c.is_whitespace()))
@@ -483,21 +371,20 @@ mod test {
    #[test]
    fn line_composer_max_line_width_of_1_double_width_characters() {
        let width = 1;
-        let text =
-            "コンピュータ上で文字を扱う場合、典型的には文字\naaa\naによる通信を行う場合にその\
+        let text = "コンピュータ上で文字を扱う場合、典型的には文字\naaaによる通信を行う場合にその\
                    両端点では、";
-        let (word_wrapper, _, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
-        let (line_truncator, _, _) = run_composer(Composer::LineTruncator, text, width);
-        assert_eq!(word_wrapper, vec!["", "a", "a", "a", "a"]);
-        assert_eq!(line_truncator, vec!["", "a", "a"]);
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+        assert_eq!(word_wrapper, vec!["", "a", "a", "a"]);
+        assert_eq!(line_truncator, vec!["", "a"]);
    }

-    /// Tests `WordWrapper` with words some of which exceed line length and some not.
+    /// Tests WordWrapper with words some of which exceed line length and some not.
    #[test]
    fn line_composer_word_wrapper_mixed_length() {
        let width = 20;
        let text = "abcd efghij klmnopabcdefghijklmnopabcdefghijkl mnopab cdefghi j klmno";
-        let (word_wrapper, _, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
        assert_eq!(
            word_wrapper,
            vec![
@@ -507,7 +394,7 @@ mod test {
                "mnopab cdefghi j",
                "klmno",
            ]
-        );
+        )
    }

    #[test]
@@ -515,9 +402,9 @@ mod test {
        let width = 20;
        let text = "コンピュータ上で文字を扱う場合、典型的には文字による通信を行う場合にその両端点\
                    では、";
-        let (word_wrapper, word_wrapper_width, _) =
-            run_composer(Composer::WordWrapper { trim: true }, text, width);
-        let (line_truncator, _, _) = run_composer(Composer::LineTruncator, text, width);
+        let (word_wrapper, word_wrapper_width) =
+            run_composer(Composer::WordWrapper { trim: true }, &text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, &text, width);
        assert_eq!(line_truncator, vec!["コンピュータ上で文字"]);
        let wrapped = vec![
            "コンピュータ上で文字",
@@ -534,8 +421,8 @@ mod test {
    fn line_composer_leading_whitespace_removal() {
        let width = 20;
        let text = "AAAAAAAAAAAAAAAAAAAA    AAA";
-        let (word_wrapper, _, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
-        let (line_truncator, _, _) = run_composer(Composer::LineTruncator, text, width);
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
        assert_eq!(word_wrapper, vec!["AAAAAAAAAAAAAAAAAAAA", "AAA",]);
        assert_eq!(line_truncator, vec!["AAAAAAAAAAAAAAAAAAAA"]);
    }
@@ -545,20 +432,20 @@ mod test {
    fn line_composer_lots_of_spaces() {
        let width = 20;
        let text = "                                                                     ";
-        let (word_wrapper, _, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
-        let (line_truncator, _, _) = run_composer(Composer::LineTruncator, text, width);
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
        assert_eq!(word_wrapper, vec![""]);
        assert_eq!(line_truncator, vec!["                    "]);
    }

-    /// Tests an input starting with a letter, followed by spaces - some of the behaviour is
+    /// Tests an input starting with a letter, folowed by spaces - some of the behaviour is
    /// incidental.
    #[test]
    fn line_composer_char_plus_lots_of_spaces() {
        let width = 20;
        let text = "a                                                                     ";
-        let (word_wrapper, _, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
-        let (line_truncator, _, _) = run_composer(Composer::LineTruncator, text, width);
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
        // What's happening below is: the first line gets consumed, trailing spaces discarded,
        // after 20 of which a word break occurs (probably shouldn't). The second line break
        // discards all whitespace. The result should probably be vec!["a"] but it doesn't matter
@@ -574,10 +461,9 @@ mod test {
        // to test double-width chars.
        // You are more than welcome to add word boundary detection based of alterations of
        // hiragana and katakana...
-        // This happens to also be a test case for mixed width because regular spaces are single
-        // width.
+        // This happens to also be a test case for mixed width because regular spaces are single width.
        let text = "コンピュ ータ上で文字を扱う場合、 典型的には文 字による 通信を行 う場合にその両端点では、";
-        let (word_wrapper, word_wrapper_width, _) =
+        let (word_wrapper, word_wrapper_width) =
            run_composer(Composer::WordWrapper { trim: true }, text, width);
        assert_eq!(
            word_wrapper,
@@ -599,24 +485,21 @@ mod test {
    fn line_composer_word_wrapper_nbsp() {
        let width = 20;
        let text = "AAAAAAAAAAAAAAA AAAA\u{00a0}AAA";
-        let (word_wrapper, word_wrapper_widths, _) =
-            run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
        assert_eq!(word_wrapper, vec!["AAAAAAAAAAAAAAA", "AAAA\u{00a0}AAA",]);
-        assert_eq!(word_wrapper_widths, vec![15, 8]);

        // Ensure that if the character was a regular space, it would be wrapped differently.
-        let text_space = text.replace('\u{00a0}', " ");
-        let (word_wrapper_space, word_wrapper_widths, _) =
-            run_composer(Composer::WordWrapper { trim: true }, text_space, width);
+        let text_space = text.replace("\u{00a0}", " ");
+        let (word_wrapper_space, _) =
+            run_composer(Composer::WordWrapper { trim: true }, &text_space, width);
        assert_eq!(word_wrapper_space, vec!["AAAAAAAAAAAAAAA AAAA", "AAA",]);
-        assert_eq!(word_wrapper_widths, vec![20, 3])
    }

    #[test]
    fn line_composer_word_wrapper_preserve_indentation() {
        let width = 20;
        let text = "AAAAAAAAAAAAAAAAAAAA    AAA";
-        let (word_wrapper, _, _) = run_composer(Composer::WordWrapper { trim: false }, text, width);
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: false }, text, width);
        assert_eq!(word_wrapper, vec!["AAAAAAAAAAAAAAAAAAAA", "   AAA",]);
    }

@@ -624,7 +507,7 @@ mod test {
    fn line_composer_word_wrapper_preserve_indentation_with_wrap() {
        let width = 10;
        let text = "AAA AAA AAAAA AA AAAAAA\n B\n  C\n   D";
-        let (word_wrapper, _, _) = run_composer(Composer::WordWrapper { trim: false }, text, width);
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: false }, text, width);
        assert_eq!(
            word_wrapper,
            vec!["AAA AAA", "AAAAA AA", "AAAAAA", " B", "  C", "   D"]
@@ -635,7 +518,7 @@ mod test {
    fn line_composer_word_wrapper_preserve_indentation_lots_of_whitespace() {
        let width = 10;
        let text = "               4 Indent\n                 must wrap!";
-        let (word_wrapper, _, _) = run_composer(Composer::WordWrapper { trim: false }, text, width);
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: false }, text, width);
        assert_eq!(
            word_wrapper,
            vec![
@@ -648,43 +531,4 @@ mod test {
            ]
        );
    }
-
-    #[test]
-    fn line_composer_zero_width_at_end() {
-        let width = 3;
-        let line = "foo\0";
-        let (word_wrapper, _, _) = run_composer(Composer::WordWrapper { trim: true }, line, width);
-        let (line_truncator, _, _) = run_composer(Composer::LineTruncator, line, width);
-        assert_eq!(word_wrapper, vec!["foo\0"]);
-        assert_eq!(line_truncator, vec!["foo\0"]);
-    }
-
-    #[test]
-    fn line_composer_preserves_line_alignment() {
-        let width = 20;
-        let lines = vec![
-            Line::from("Something that is left aligned.").alignment(Alignment::Left),
-            Line::from("This is right aligned and half short.").alignment(Alignment::Right),
-            Line::from("This should sit in the center.").alignment(Alignment::Center),
-        ];
-        let (_, _, wrapped_alignments) =
-            run_composer(Composer::WordWrapper { trim: true }, lines.clone(), width);
-        let (_, _, truncated_alignments) = run_composer(Composer::LineTruncator, lines, width);
-        assert_eq!(
-            wrapped_alignments,
-            vec![
-                Alignment::Left,
-                Alignment::Left,
-                Alignment::Right,
-                Alignment::Right,
-                Alignment::Right,
-                Alignment::Center,
-                Alignment::Center
-            ]
-        );
-        assert_eq!(
-            truncated_alignments,
-            vec![Alignment::Left, Alignment::Right, Alignment::Center]
-        );
-    }
 }
--- a/src/widgets/scrollbar.rs
+++ b/src/widgets/scrollbar.rs
@@ -1,881 +0,0 @@
-use super::StatefulWidget;
-use crate::{
-    buffer::Buffer,
-    layout::Rect,
-    style::Style,
-    symbols::{block::FULL, line},
-};
-
-/// Scrollbar Set
-/// ```text
-/// <--▮------->
-/// ^  ^   ^   ^
-/// │  │   │   └ end
-/// │  │   └──── track
-/// │  └──────── thumb
-/// └─────────── begin
-/// ```
-#[derive(Debug, Clone)]
-pub struct Set {
-    pub track: &'static str,
-    pub thumb: &'static str,
-    pub begin: &'static str,
-    pub end: &'static str,
-}
-
-pub const DOUBLE_VERTICAL: Set = Set {
-    track: line::DOUBLE_VERTICAL,
-    thumb: FULL,
-    begin: "▲",
-    end: "▼",
-};
-
-pub const DOUBLE_HORIZONTAL: Set = Set {
-    track: line::DOUBLE_HORIZONTAL,
-    thumb: FULL,
-    begin: "◄",
-    end: "►",
-};
-
-pub const VERTICAL: Set = Set {
-    track: line::VERTICAL,
-    thumb: FULL,
-    begin: "↑",
-    end: "↓",
-};
-
-pub const HORIZONTAL: Set = Set {
-    track: line::HORIZONTAL,
-    thumb: FULL,
-    begin: "←",
-    end: "→",
-};
-
-/// An enum representing the direction of scrolling in a Scrollbar widget.
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-pub enum ScrollDirection {
-    /// Forward scroll direction, usually corresponds to scrolling downwards or rightwards.
-    #[default]
-    Forward,
-    /// Backward scroll direction, usually corresponds to scrolling upwards or leftwards.
-    Backward,
-}
-
-/// A struct representing the state of a Scrollbar widget.
-///
-/// For example, in the following list, assume there are 4 bullet points:
-///
-/// - the `position` is 0
-/// - the `content_length` is 4
-/// - the `viewport_content_length` is 2
-///
-/// ```text
-/// ┌───────────────┐
-/// │1. this is a   █
-/// │   single item █
-/// │2. this is a   ║
-/// │   second item ║
-/// └───────────────┘
-/// ```
-///
-/// If you don't have multi-line content, you can leave the `viewport_content_length` set to the
-/// default of 0 and it'll use the track size as a `viewport_content_length`.
-#[derive(Clone, Copy, Debug, Default)]
-pub struct ScrollbarState {
-    // The current position within the scrollable content.
-    position: u16,
-    // The total length of the scrollable content.
-    content_length: u16,
-    // The length of content in current viewport.
-    viewport_content_length: u16,
-}
-
-impl ScrollbarState {
-    /// Sets the scroll position of the scrollbar and returns the modified ScrollbarState.
-    pub fn position(mut self, position: u16) -> Self {
-        self.position = position;
-        self
-    }
-
-    /// Sets the length of the scrollable content and returns the modified ScrollbarState.
-    pub fn content_length(mut self, content_length: u16) -> Self {
-        self.content_length = content_length;
-        self
-    }
-
-    /// Sets the length of the viewport content and returns the modified ScrollbarState.
-    pub fn viewport_content_length(mut self, viewport_content_length: u16) -> Self {
-        self.viewport_content_length = viewport_content_length;
-        self
-    }
-
-    /// Decrements the scroll position by one, ensuring it doesn't go below zero.
-    pub fn prev(&mut self) {
-        self.position = self.position.saturating_sub(1);
-    }
-
-    /// Increments the scroll position by one, ensuring it doesn't exceed the length of the content.
-    pub fn next(&mut self) {
-        self.position = self
-            .position
-            .saturating_add(1)
-            .clamp(0, self.content_length.saturating_sub(1))
-    }
-
-    /// Sets the scroll position to the start of the scrollable content.
-    pub fn first(&mut self) {
-        self.position = 0;
-    }
-
-    /// Sets the scroll position to the end of the scrollable content.
-    pub fn last(&mut self) {
-        self.position = self.content_length.saturating_sub(1)
-    }
-
-    /// Changes the scroll position based on the provided ScrollDirection.
-    pub fn scroll(&mut self, direction: ScrollDirection) {
-        match direction {
-            ScrollDirection::Forward => {
-                self.next();
-            }
-            ScrollDirection::Backward => {
-                self.prev();
-            }
-        }
-    }
-}
-
-/// Scrollbar Orientation
-#[derive(Default, Debug, Clone)]
-pub enum ScrollbarOrientation {
-    #[default]
-    VerticalRight,
-    VerticalLeft,
-    HorizontalBottom,
-    HorizontalTop,
-}
-
-/// Scrollbar widget for tui-rs library.
-///
-/// This widget can be used to display a scrollbar in a terminal user interface.
-/// The following components of the scrollbar are customizable in symbol and style.
-///
-/// ```text
-/// <--▮------->
-/// ^  ^   ^   ^
-/// │  │   │   └ end
-/// │  │   └──── track
-/// │  └──────── thumb
-/// └─────────── begin
-/// ```
-#[derive(Debug, Clone)]
-pub struct Scrollbar<'a> {
-    orientation: ScrollbarOrientation,
-    thumb_style: Style,
-    thumb_symbol: &'a str,
-    track_style: Style,
-    track_symbol: &'a str,
-    begin_symbol: Option<&'a str>,
-    begin_style: Style,
-    end_symbol: Option<&'a str>,
-    end_style: Style,
-}
-
-impl<'a> Default for Scrollbar<'a> {
-    fn default() -> Self {
-        Self {
-            orientation: ScrollbarOrientation::default(),
-            thumb_symbol: DOUBLE_VERTICAL.thumb,
-            thumb_style: Style::default(),
-            track_symbol: DOUBLE_VERTICAL.track,
-            track_style: Style::default(),
-            begin_symbol: Some(DOUBLE_VERTICAL.begin),
-            begin_style: Style::default(),
-            end_symbol: Some(DOUBLE_VERTICAL.end),
-            end_style: Style::default(),
-        }
-    }
-}
-
-impl<'a> Scrollbar<'a> {
-    pub fn new(orientation: ScrollbarOrientation) -> Self {
-        Self::default().orientation(orientation)
-    }
-
-    /// Sets the orientation of the scrollbar.
-    /// Resets the symbols to [`DOUBLE_VERTICAL`] or [`DOUBLE_HORIZONTAL`] based on orientation
-    pub fn orientation(mut self, orientation: ScrollbarOrientation) -> Self {
-        self.orientation = orientation;
-        let set = if self.is_vertical() {
-            DOUBLE_VERTICAL
-        } else {
-            DOUBLE_HORIZONTAL
-        };
-        self.symbols(set)
-    }
-
-    /// Sets the orientation and symbols for the scrollbar from a [`Set`].
-    pub fn orientation_and_symbol(mut self, orientation: ScrollbarOrientation, set: Set) -> Self {
-        self.orientation = orientation;
-        self.symbols(set)
-    }
-
-    /// Sets the symbol that represents the thumb of the scrollbar.
-    pub fn thumb_symbol(mut self, thumb_symbol: &'a str) -> Self {
-        self.thumb_symbol = thumb_symbol;
-        self
-    }
-
-    /// Sets the style that represents the thumb of the scrollbar.
-    pub fn thumb_style(mut self, thumb_style: Style) -> Self {
-        self.thumb_style = thumb_style;
-        self
-    }
-
-    /// Sets the symbol that represents the track of the scrollbar.
-    pub fn track_symbol(mut self, track_symbol: &'a str) -> Self {
-        self.track_symbol = track_symbol;
-        self
-    }
-
-    /// Sets the style that is used for the track of the scrollbar.
-    pub fn track_style(mut self, track_style: Style) -> Self {
-        self.track_style = track_style;
-        self
-    }
-
-    /// Sets the symbol that represents the beginning of the scrollbar.
-    pub fn begin_symbol(mut self, begin_symbol: Option<&'a str>) -> Self {
-        self.begin_symbol = begin_symbol;
-        self
-    }
-
-    /// Sets the style that is used for the beginning of the scrollbar.
-    pub fn begin_style(mut self, begin_style: Style) -> Self {
-        self.begin_style = begin_style;
-        self
-    }
-
-    /// Sets the symbol that represents the end of the scrollbar.
-    pub fn end_symbol(mut self, end_symbol: Option<&'a str>) -> Self {
-        self.end_symbol = end_symbol;
-        self
-    }
-
-    /// Sets the style that is used for the end of the scrollbar.
-    pub fn end_style(mut self, end_style: Style) -> Self {
-        self.end_style = end_style;
-        self
-    }
-
-    /// Sets the symbols used for the various parts of the scrollbar from a [`Set`].
-    ///
-    /// ```text
-    /// <--▮------->
-    /// ^  ^   ^   ^
-    /// │  │   │   └ end
-    /// │  │   └──── track
-    /// │  └──────── thumb
-    /// └─────────── begin
-    /// ```
-    ///
-    /// Only sets begin_symbol and end_symbol if they already contain a value.
-    /// If begin_symbol and/or end_symbol were set to `None` explicitly, this function will respect
-    /// that choice.
-    pub fn symbols(mut self, symbol: Set) -> Self {
-        self.track_symbol = symbol.track;
-        self.thumb_symbol = symbol.thumb;
-        if self.begin_symbol.is_some() {
-            self.begin_symbol = Some(symbol.begin);
-        }
-        if self.end_symbol.is_some() {
-            self.end_symbol = Some(symbol.end);
-        }
-        self
-    }
-
-    /// Sets the style used for the various parts of the scrollbar from a [`Style`].
-    /// ```text
-    /// <--▮------->
-    /// ^  ^   ^   ^
-    /// │  │   │   └ end
-    /// │  │   └──── track
-    /// │  └──────── thumb
-    /// └─────────── begin
-    /// ```
-    pub fn style(mut self, style: Style) -> Self {
-        self.track_style = style;
-        self.thumb_style = style;
-        self.begin_style = style;
-        self.end_style = style;
-        self
-    }
-
-    fn is_vertical(&self) -> bool {
-        match self.orientation {
-            ScrollbarOrientation::VerticalRight | ScrollbarOrientation::VerticalLeft => true,
-            ScrollbarOrientation::HorizontalBottom | ScrollbarOrientation::HorizontalTop => false,
-        }
-    }
-
-    fn get_track_area(&self, area: Rect) -> Rect {
-        // Decrease track area if a begin arrow is present
-        let area = if self.begin_symbol.is_some() {
-            if self.is_vertical() {
-                // For vertical scrollbar, reduce the height by one
-                Rect::new(
-                    area.x,
-                    area.y + 1,
-                    area.width,
-                    area.height.saturating_sub(1),
-                )
-            } else {
-                // For horizontal scrollbar, reduce the width by one
-                Rect::new(
-                    area.x + 1,
-                    area.y,
-                    area.width.saturating_sub(1),
-                    area.height,
-                )
-            }
-        } else {
-            area
-        };
-        // Further decrease scrollbar area if an end arrow is present
-        if self.end_symbol.is_some() {
-            if self.is_vertical() {
-                // For vertical scrollbar, reduce the height by one
-                Rect::new(area.x, area.y, area.width, area.height.saturating_sub(1))
-            } else {
-                // For horizontal scrollbar, reduce the width by one
-                Rect::new(area.x, area.y, area.width.saturating_sub(1), area.height)
-            }
-        } else {
-            area
-        }
-    }
-
-    fn should_not_render(&self, track_start: u16, track_end: u16, content_length: u16) -> bool {
-        if track_end - track_start == 0 || content_length == 0 {
-            return true;
-        }
-        false
-    }
-
-    fn get_track_start_end(&self, area: Rect) -> (u16, u16, u16) {
-        match self.orientation {
-            ScrollbarOrientation::VerticalRight => {
-                (area.top(), area.bottom(), area.right().saturating_sub(1))
-            }
-            ScrollbarOrientation::VerticalLeft => (area.top(), area.bottom(), area.left()),
-            ScrollbarOrientation::HorizontalBottom => {
-                (area.left(), area.right(), area.bottom().saturating_sub(1))
-            }
-            ScrollbarOrientation::HorizontalTop => (area.left(), area.right(), area.top()),
-        }
-    }
-
-    /// Calculate the starting and ending position of a scrollbar thumb.
-    ///
-    /// The scrollbar thumb's position and size are determined based on the current state of the
-    /// scrollbar, and the dimensions of the scrollbar track.
-    ///
-    /// This function returns a tuple `(thumb_start, thumb_end)` where `thumb_start` is the position
-    /// at which the scrollbar thumb begins, and `thumb_end` is the position at which the
-    /// scrollbar thumb ends.
-    ///
-    /// The size of the thumb (i.e., `thumb_end - thumb_start`) is proportional to the ratio of the
-    /// viewport content length to the total content length.
-    ///
-    /// The position of the thumb (i.e., `thumb_start`) is proportional to the ratio of the current
-    /// scroll position to the total content length.
-    fn get_thumb_start_end(
-        &self,
-        state: &ScrollbarState,
-        track_start_end: (u16, u16),
-    ) -> (u16, u16) {
-        // let (track_start, track_end) = track_start_end;
-        // let track_size = track_end - track_start;
-        // let thumb_size =
-        //     ((state.viewport_content_length / state.content_length) * track_size).max(1);
-        // let thumb_start = (state.position / state.content_length) *
-        //                    state.viewport_content_length;
-        // let thumb_end = thumb_size + thumb_start;
-        // (thumb_start, thumb_end)
-
-        let (track_start, track_end) = track_start_end;
-
-        let viewport_content_length = if state.viewport_content_length == 0 {
-            track_end - track_start
-        } else {
-            state.viewport_content_length
-        };
-
-        let scroll_position_ratio = (state.position as f64 / state.content_length as f64).min(1.0);
-
-        let thumb_size = (((viewport_content_length as f64 / state.content_length as f64)
-            * (track_end - track_start) as f64)
-            .round() as u16)
-            .max(1);
-
-        let track_size = (track_end - track_start).saturating_sub(thumb_size);
-
-        let thumb_start = track_start + (scroll_position_ratio * track_size as f64).round() as u16;
-
-        let thumb_end = thumb_start + thumb_size;
-
-        (thumb_start, thumb_end)
-    }
-}
-
-impl<'a> StatefulWidget for Scrollbar<'a> {
-    type State = ScrollbarState;
-
-    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
-        //
-        // For ScrollbarOrientation::VerticalRight
-        //
-        //                   ┌───────── track_axis  (x)
-        //                   v
-        //   ┌───────────────┐
-        //   │               ║<──────── track_start (y1)
-        //   │               █
-        //   │               █
-        //   │               ║
-        //   │               ║<──────── track_end   (y2)
-        //   └───────────────┘
-        //
-        // For ScrollbarOrientation::HorizontalBottom
-        //
-        //   ┌───────────────┐
-        //   │               │
-        //   │               │
-        //   │               │
-        //   └═══███═════════┘<──────── track_axis  (y)
-        //    ^             ^
-        //    │             └────────── track_end   (x2)
-        //    │
-        //    └──────────────────────── track_start (x1)
-        //
-
-        // Find track_start, track_end, and track_axis
-        let area = self.get_track_area(area);
-        let (track_start, track_end, track_axis) = self.get_track_start_end(area);
-
-        if self.should_not_render(track_start, track_end, state.content_length) {
-            return;
-        }
-
-        let (thumb_start, thumb_end) = self.get_thumb_start_end(state, (track_start, track_end));
-
-        for i in track_start..track_end {
-            let (style, symbol) = if i >= thumb_start && i < thumb_end {
-                (self.thumb_style, self.thumb_symbol)
-            } else {
-                (self.track_style, self.track_symbol)
-            };
-
-            if self.is_vertical() {
-                buf.set_string(track_axis, i, symbol, style);
-            } else {
-                buf.set_string(i, track_axis, symbol, style);
-            }
-        }
-
-        if let Some(s) = self.begin_symbol {
-            if self.is_vertical() {
-                buf.set_string(track_axis, track_start - 1, s, self.begin_style);
-            } else {
-                buf.set_string(track_start - 1, track_axis, s, self.begin_style);
-            }
-        };
-        if let Some(s) = self.end_symbol {
-            if self.is_vertical() {
-                buf.set_string(track_axis, track_end, s, self.end_style);
-            } else {
-                buf.set_string(track_end, track_axis, s, self.end_style);
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::assert_buffer_eq;
-
-    #[test]
-    fn test_no_render_when_area_zero() {
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 0, 0));
-        let mut state = ScrollbarState::default().position(0).content_length(1);
-        Scrollbar::default().render(buffer.area, &mut buffer, &mut state);
-        assert_buffer_eq!(buffer, Buffer::empty(buffer.area));
-    }
-
-    #[test]
-    fn test_no_render_when_height_zero_with_without_arrows() {
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 3, 0));
-        let mut state = ScrollbarState::default().position(0).content_length(1);
-        Scrollbar::default().render(buffer.area, &mut buffer, &mut state);
-        assert_buffer_eq!(buffer, Buffer::empty(buffer.area));
-
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 3, 0));
-        let mut state = ScrollbarState::default().position(0).content_length(1);
-        Scrollbar::default()
-            .begin_symbol(None)
-            .end_symbol(None)
-            .render(buffer.area, &mut buffer, &mut state);
-        assert_buffer_eq!(buffer, Buffer::empty(buffer.area));
-    }
-
-    #[test]
-    fn test_no_render_when_height_too_small_for_arrows() {
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 4, 2));
-        let mut state = ScrollbarState::default().position(0).content_length(1);
-        Scrollbar::default().render(buffer.area, &mut buffer, &mut state);
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["    ", "    "]));
-    }
-
-    #[test]
-    fn test_renders_all_thumbs_at_minimum_height_without_arrows() {
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 4, 2));
-        let mut state = ScrollbarState::default().position(0).content_length(1);
-        Scrollbar::default()
-            .begin_symbol(None)
-            .end_symbol(None)
-            .render(buffer.area, &mut buffer, &mut state);
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["   █", "   █"]));
-    }
-
-    #[test]
-    fn test_renders_all_thumbs_at_minimum_height_and_minimum_width_without_arrows() {
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 1, 2));
-        let mut state = ScrollbarState::default().position(0).content_length(1);
-        Scrollbar::default()
-            .begin_symbol(None)
-            .end_symbol(None)
-            .render(buffer.area, &mut buffer, &mut state);
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["█", "█"]));
-    }
-
-    #[test]
-    fn test_renders_two_arrows_one_thumb_at_minimum_height_with_arrows() {
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 4, 3));
-        let mut state = ScrollbarState::default().position(0).content_length(1);
-        Scrollbar::default().render(buffer.area, &mut buffer, &mut state);
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["   ▲", "   █", "   ▼"]));
-    }
-
-    #[test]
-    fn test_no_render_when_content_length_zero() {
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 2, 2));
-        let mut state = ScrollbarState::default().position(0).content_length(0);
-        Scrollbar::default().render(buffer.area, &mut buffer, &mut state);
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["  ", "  "]));
-    }
-
-    #[test]
-    fn test_renders_all_thumbs_when_height_equals_content_length() {
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 2, 2));
-        let mut state = ScrollbarState::default().position(0).content_length(2);
-        Scrollbar::default()
-            .begin_symbol(None)
-            .end_symbol(None)
-            .render(buffer.area, &mut buffer, &mut state);
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec![" █", " █"]));
-
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 2, 8));
-        let mut state = ScrollbarState::default().position(0).content_length(8);
-        Scrollbar::default()
-            .begin_symbol(None)
-            .end_symbol(None)
-            .render(buffer.area, &mut buffer, &mut state);
-        assert_buffer_eq!(
-            buffer,
-            Buffer::with_lines(vec![" █", " █", " █", " █", " █", " █", " █", " █"])
-        );
-    }
-
-    #[test]
-    fn test_renders_single_vertical_thumb_when_content_length_square_of_height() {
-        for i in 0..=17 {
-            let mut buffer = Buffer::empty(Rect::new(0, 0, 2, 4));
-            let mut state = ScrollbarState::default().position(i).content_length(16);
-            Scrollbar::default()
-                .begin_symbol(None)
-                .end_symbol(None)
-                .render(buffer.area, &mut buffer, &mut state);
-            let expected = if i <= 2 {
-                vec![" █", " ║", " ║", " ║"]
-            } else if i <= 7 {
-                vec![" ║", " █", " ║", " ║"]
-            } else if i <= 13 {
-                vec![" ║", " ║", " █", " ║"]
-            } else {
-                vec![" ║", " ║", " ║", " █"]
-            };
-            assert_buffer_eq!(buffer, Buffer::with_lines(expected.clone()));
-        }
-    }
-
-    #[test]
-    fn test_renders_single_horizontal_thumb_when_content_length_square_of_width() {
-        for i in 0..=17 {
-            let mut buffer = Buffer::empty(Rect::new(0, 0, 4, 2));
-            let mut state = ScrollbarState::default().position(i).content_length(16);
-            Scrollbar::default()
-                .begin_symbol(None)
-                .end_symbol(None)
-                .orientation(ScrollbarOrientation::HorizontalBottom)
-                .render(buffer.area, &mut buffer, &mut state);
-            let expected = if i <= 2 {
-                vec!["    ", "█═══"]
-            } else if i <= 7 {
-                vec!["    ", "═█══"]
-            } else if i <= 13 {
-                vec!["    ", "══█═"]
-            } else {
-                vec!["    ", "═══█"]
-            };
-            assert_buffer_eq!(buffer, Buffer::with_lines(expected.clone()));
-        }
-    }
-
-    #[test]
-    fn test_renders_one_thumb_for_large_content_relative_to_height() {
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 4, 2));
-        let mut state = ScrollbarState::default().position(0).content_length(1600);
-        Scrollbar::default()
-            .begin_symbol(None)
-            .end_symbol(None)
-            .orientation(ScrollbarOrientation::HorizontalBottom)
-            .render(buffer.area, &mut buffer, &mut state);
-        let expected = vec!["    ", "█═══"];
-        assert_buffer_eq!(buffer, Buffer::with_lines(expected.clone()));
-
-        let mut buffer = Buffer::empty(Rect::new(0, 0, 4, 2));
-        let mut state = ScrollbarState::default().position(800).content_length(1600);
-        Scrollbar::default()
-            .begin_symbol(None)
-            .end_symbol(None)
-            .orientation(ScrollbarOrientation::HorizontalBottom)
-            .render(buffer.area, &mut buffer, &mut state);
-        let expected = vec!["    ", "══█═"];
-        assert_buffer_eq!(buffer, Buffer::with_lines(expected.clone()));
-    }
-
-    #[test]
-    fn test_renders_two_thumb_default_symbols_for_content_double_height() {
-        for i in 0..=7 {
-            let mut buffer = Buffer::empty(Rect::new(0, 0, 2, 4));
-            let mut state = ScrollbarState::default().position(i).content_length(8);
-            Scrollbar::default()
-                .begin_symbol(None)
-                .end_symbol(None)
-                .render(buffer.area, &mut buffer, &mut state);
-            let expected = if i <= 1 {
-                vec![" █", " █", " ║", " ║"]
-            } else if i <= 5 {
-                vec![" ║", " █", " █", " ║"]
-            } else {
-                vec![" ║", " ║", " █", " █"]
-            };
-            assert_buffer_eq!(buffer, Buffer::with_lines(expected.clone()));
-        }
-    }
-
-    #[test]
-    fn test_renders_two_thumb_custom_symbols_for_content_double_height() {
-        for i in 0..=7 {
-            let mut buffer = Buffer::empty(Rect::new(0, 0, 2, 4));
-            let mut state = ScrollbarState::default().position(i).content_length(8);
-            Scrollbar::default()
-                .symbols(VERTICAL)
-                .begin_symbol(None)
-                .end_symbol(None)
-                .render(buffer.area, &mut buffer, &mut state);
-            let expected = if i <= 1 {
-                vec![" █", " █", " │", " │"]
-            } else if i <= 5 {
-                vec![" │", " █", " █", " │"]
-            } else {
-                vec![" │", " │", " █", " █"]
-            };
-            assert_buffer_eq!(buffer, Buffer::with_lines(expected.clone()));
-        }
-    }
-
-    #[test]
-    fn test_renders_two_thumb_default_symbols_for_content_double_width() {
-        for i in 0..=7 {
-            let mut buffer = Buffer::empty(Rect::new(0, 0, 4, 2));
-            let mut state = ScrollbarState::default().position(i).content_length(8);
-            Scrollbar::default()
-                .orientation(ScrollbarOrientation::HorizontalBottom)
-                .begin_symbol(None)
-                .end_symbol(None)
-                .render(buffer.area, &mut buffer, &mut state);
-            let expected = if i <= 1 {
-                vec!["    ", "██══"]
-            } else if i <= 5 {
-                vec!["    ", "═██═"]
-            } else {
-                vec!["    ", "══██"]
-            };
-            assert_buffer_eq!(buffer, Buffer::with_lines(expected.clone()));
-        }
-    }
-
-    #[test]
-    fn test_renders_two_thumb_custom_symbols_for_content_double_width() {
-        for i in 0..=7 {
-            let mut buffer = Buffer::empty(Rect::new(0, 0, 4, 2));
-            let mut state = ScrollbarState::default().position(i).content_length(8);
-            Scrollbar::default()
-                .orientation(ScrollbarOrientation::HorizontalBottom)
-                .symbols(HORIZONTAL)
-                .begin_symbol(None)
-                .end_symbol(None)
-                .render(buffer.area, &mut buffer, &mut state);
-            let expected = if i <= 1 {
-                vec!["    ", "██──"]
-            } else if i <= 5 {
-                vec!["    ", "─██─"]
-            } else {
-                vec!["    ", "──██"]
-            };
-            assert_buffer_eq!(buffer, Buffer::with_lines(expected.clone()));
-        }
-    }
-
-    #[test]
-    fn test_rendering_viewport_content_length() {
-        for i in 0..=16 {
-            let mut buffer = Buffer::empty(Rect::new(0, 0, 8, 2));
-            let mut state = ScrollbarState::default()
-                .position(i)
-                .content_length(16)
-                .viewport_content_length(4);
-            Scrollbar::default()
-                .orientation(ScrollbarOrientation::HorizontalBottom)
-                .begin_symbol(Some(DOUBLE_HORIZONTAL.begin))
-                .end_symbol(Some(DOUBLE_HORIZONTAL.end))
-                .render(buffer.area, &mut buffer, &mut state);
-            let expected = if i <= 1 {
-                vec!["        ", "◄██════►"]
-            } else if i <= 5 {
-                vec!["        ", "◄═██═══►"]
-            } else if i <= 9 {
-                vec!["        ", "◄══██══►"]
-            } else if i <= 13 {
-                vec!["        ", "◄═══██═►"]
-            } else {
-                vec!["        ", "◄════██►"]
-            };
-            assert_buffer_eq!(buffer, Buffer::with_lines(expected.clone()));
-        }
-
-        for i in 0..=16 {
-            let mut buffer = Buffer::empty(Rect::new(0, 0, 8, 2));
-            let mut state = ScrollbarState::default()
-                .position(i)
-                .content_length(16)
-                .viewport_content_length(1);
-            Scrollbar::default()
-                .orientation(ScrollbarOrientation::HorizontalBottom)
-                .begin_symbol(Some(DOUBLE_HORIZONTAL.begin))
-                .end_symbol(Some(DOUBLE_HORIZONTAL.end))
-                .render(buffer.area, &mut buffer, &mut state);
-            dbg!(i);
-            let expected = if i <= 1 {
-                vec!["        ", "◄█═════►"]
-            } else if i <= 4 {
-                vec!["        ", "◄═█════►"]
-            } else if i <= 7 {
-                vec!["        ", "◄══█═══►"]
-            } else if i <= 11 {
-                vec!["        ", "◄═══█══►"]
-            } else if i <= 14 {
-                vec!["        ", "◄════█═►"]
-            } else {
-                vec!["        ", "◄═════█►"]
-            };
-            assert_buffer_eq!(buffer, Buffer::with_lines(expected.clone()));
-        }
-    }
-
-    #[test]
-    fn test_rendering_begin_end_arrows_horizontal_bottom() {
-        for i in 0..=16 {
-            let mut buffer = Buffer::empty(Rect::new(0, 0, 8, 2));
-            let mut state = ScrollbarState::default().position(i).content_length(16);
-            Scrollbar::default()
-                .orientation(ScrollbarOrientation::HorizontalBottom)
-                .begin_symbol(Some(DOUBLE_HORIZONTAL.begin))
-                .end_symbol(Some(DOUBLE_HORIZONTAL.end))
-                .render(buffer.area, &mut buffer, &mut state);
-            let expected = if i <= 1 {
-                vec!["        ", "◄██════►"]
-            } else if i <= 5 {
-                vec!["        ", "◄═██═══►"]
-            } else if i <= 9 {
-                vec!["        ", "◄══██══►"]
-            } else if i <= 13 {
-                vec!["        ", "◄═══██═►"]
-            } else {
-                vec!["        ", "◄════██►"]
-            };
-            assert_buffer_eq!(buffer, Buffer::with_lines(expected.clone()));
-        }
-    }
-
-    #[test]
-    fn test_rendering_begin_end_arrows_horizontal_top() {
-        for i in 0..=16 {
-            let mut buffer = Buffer::empty(Rect::new(0, 0, 8, 2));
-            let mut state = ScrollbarState::default().position(i).content_length(16);
-            Scrollbar::default()
-                .orientation(ScrollbarOrientation::HorizontalTop)
-                .begin_symbol(Some(DOUBLE_HORIZONTAL.begin))
-                .end_symbol(Some(DOUBLE_HORIZONTAL.end))
-                .render(buffer.area, &mut buffer, &mut state);
-            let expected = if i <= 1 {
-                vec!["◄██════►", "        "]
-            } else if i <= 5 {
-                vec!["◄═██═══►", "        "]
-            } else if i <= 9 {
-                vec!["◄══██══►", "        "]
-            } else if i <= 13 {
-                vec!["◄═══██═►", "        "]
-            } else {
-                vec!["◄════██►", "        "]
-            };
-            assert_buffer_eq!(buffer, Buffer::with_lines(expected.clone()));
-        }
-    }
-
-    #[test]
-    fn test_rendering_only_begin_arrow_horizontal_bottom() {
-        for i in 0..=16 {
-            let mut buffer = Buffer::empty(Rect::new(0, 0, 8, 2));
-            let mut state = ScrollbarState::default().position(i).content_length(16);
-            Scrollbar::default()
-                .orientation(ScrollbarOrientation::HorizontalBottom)
-                .begin_symbol(Some(DOUBLE_HORIZONTAL.begin))
-                .end_symbol(None)
-                .render(buffer.area, &mut buffer, &mut state);
-            let expected = if i <= 1 {
-                vec!["        ", "◄███════"]
-            } else if i <= 5 {
-                vec!["        ", "◄═███═══"]
-            } else if i <= 9 {
-                vec!["        ", "◄══███══"]
-            } else if i <= 13 {
-                vec!["        ", "◄═══███═"]
-            } else {
-                vec!["        ", "◄════███"]
-            };
-            assert_buffer_eq!(buffer, Buffer::with_lines(expected.clone()));
-        }
-    }
-}
--- a/src/widgets/sparkline.rs
+++ b/src/widgets/sparkline.rs
@@ -1,5 +1,3 @@
-use std::cmp::min;
-
 use crate::{
    buffer::Buffer,
    layout::Rect,
@@ -7,14 +5,15 @@ use crate::{
    symbols,
    widgets::{Block, Widget},
 };
+use std::cmp::min;

 /// Widget to render a sparkline over one or more lines.
 ///
 /// # Examples
 ///
 /// ```
-/// # use ratatui::widgets::{Block, Borders, Sparkline};
-/// # use ratatui::style::{Style, Color};
+/// # use tui::widgets::{Block, Borders, Sparkline};
+/// # use tui::style::{Style, Color};
 /// Sparkline::default()
 ///     .block(Block::default().title("Sparkline").borders(Borders::ALL))
 ///     .data(&[0, 2, 3, 4, 1, 4, 10])
@@ -34,25 +33,16 @@ pub struct Sparkline<'a> {
    max: Option<u64>,
    /// A set of bar symbols used to represent the give data
    bar_set: symbols::bar::Set,
-    // The direction to render the sparkine, either from left to right, or from right to left
-    direction: RenderDirection,
-}
-
-#[derive(Debug, Clone, Copy)]
-pub enum RenderDirection {
-    LeftToRight,
-    RightToLeft,
 }

 impl<'a> Default for Sparkline<'a> {
    fn default() -> Sparkline<'a> {
        Sparkline {
            block: None,
-            style: Style::default(),
+            style: Default::default(),
            data: &[],
            max: None,
            bar_set: symbols::bar::NINE_LEVELS,
-            direction: RenderDirection::LeftToRight,
        }
    }
 }
@@ -82,11 +72,6 @@ impl<'a> Sparkline<'a> {
        self.bar_set = bar_set;
        self
    }
-
-    pub fn direction(mut self, direction: RenderDirection) -> Sparkline<'a> {
-        self.direction = direction;
-        self
-    }
 }

 impl<'a> Widget for Sparkline<'a> {
@@ -114,10 +99,10 @@ impl<'a> Widget for Sparkline<'a> {
            .iter()
            .take(max_index)
            .map(|e| {
-                if max == 0 {
-                    0
-                } else {
+                if max != 0 {
                    e * u64::from(spark_area.height) * 8 / max
+                } else {
+                    0
                }
            })
            .collect::<Vec<u64>>();
@@ -134,11 +119,7 @@ impl<'a> Widget for Sparkline<'a> {
                    7 => self.bar_set.seven_eighths,
                    _ => self.bar_set.full,
                };
-                let x = match self.direction {
-                    RenderDirection::LeftToRight => spark_area.left() + i as u16,
-                    RenderDirection::RightToLeft => spark_area.right() - i as u16 - 1,
-                };
-                buf.get_mut(x, spark_area.top() + j)
+                buf.get_mut(spark_area.left() + i as u16, spark_area.top() + j)
                    .set_symbol(symbol)
                    .set_style(self.style);

@@ -155,55 +136,20 @@ impl<'a> Widget for Sparkline<'a> {
 #[cfg(test)]
 mod tests {
    use super::*;
-    use crate::{assert_buffer_eq, buffer::Cell};
-
-    // Helper function to render a sparkline to a buffer with a given width
-    // filled with x symbols to make it easier to assert on the result
-    fn render(widget: Sparkline, width: u16) -> Buffer {
-        let area = Rect::new(0, 0, width, 1);
-        let mut cell = Cell::default();
-        cell.set_symbol("x");
-        let mut buffer = Buffer::filled(area, &cell);
-        widget.render(area, &mut buffer);
-        buffer
-    }

    #[test]
    fn it_does_not_panic_if_max_is_zero() {
        let widget = Sparkline::default().data(&[0, 0, 0]);
-        let buffer = render(widget, 6);
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["   xxx"]));
+        let area = Rect::new(0, 0, 3, 1);
+        let mut buffer = Buffer::empty(area);
+        widget.render(area, &mut buffer);
    }

    #[test]
    fn it_does_not_panic_if_max_is_set_to_zero() {
        let widget = Sparkline::default().data(&[0, 1, 2]).max(0);
-        let buffer = render(widget, 6);
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["   xxx"]));
-    }
-
-    #[test]
-    fn it_draws() {
-        let widget = Sparkline::default().data(&[0, 1, 2, 3, 4, 5, 6, 7, 8]);
-        let buffer = render(widget, 12);
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec![" ▁▂▃▄▅▆▇█xxx"]));
-    }
-
-    #[test]
-    fn it_renders_left_to_right() {
-        let widget = Sparkline::default()
-            .data(&[0, 1, 2, 3, 4, 5, 6, 7, 8])
-            .direction(RenderDirection::LeftToRight);
-        let buffer = render(widget, 12);
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec![" ▁▂▃▄▅▆▇█xxx"]));
-    }
-
-    #[test]
-    fn it_renders_right_to_left() {
-        let widget = Sparkline::default()
-            .data(&[0, 1, 2, 3, 4, 5, 6, 7, 8])
-            .direction(RenderDirection::RightToLeft);
-        let buffer = render(widget, 12);
-        assert_buffer_eq!(buffer, Buffer::with_lines(vec!["xxx█▇▆▅▄▃▂▁ "]));
+        let area = Rect::new(0, 0, 3, 1);
+        let mut buffer = Buffer::empty(area);
+        widget.render(area, &mut buffer);
    }
 }
--- a/src/widgets/table.rs
+++ b/src/widgets/table.rs
@@ -1,5 +1,3 @@
-use unicode_width::UnicodeWidthStr;
-
 use crate::{
    buffer::Buffer,
    layout::{Constraint, Direction, Layout, Rect},
@@ -7,20 +5,21 @@ use crate::{
    text::Text,
    widgets::{Block, StatefulWidget, Widget},
 };
+use unicode_width::UnicodeWidthStr;

 /// A [`Cell`] contains the [`Text`] to be displayed in a [`Row`] of a [`Table`].
 ///
 /// It can be created from anything that can be converted to a [`Text`].
 /// ```rust
-/// # use ratatui::widgets::Cell;
-/// # use ratatui::style::{Style, Modifier};
-/// # use ratatui::text::{Span, Line, Text};
+/// # use tui::widgets::Cell;
+/// # use tui::style::{Style, Modifier};
+/// # use tui::text::{Span, Spans, Text};
 /// # use std::borrow::Cow;
 /// Cell::from("simple string");
 ///
 /// Cell::from(Span::from("span"));
 ///
-/// Cell::from(Line::from(vec![
+/// Cell::from(Spans::from(vec![
 ///     Span::raw("a vec of "),
 ///     Span::styled("spans", Style::default().add_modifier(Modifier::BOLD))
 /// ]));
@@ -32,7 +31,7 @@ use crate::{
 ///
 /// You can apply a [`Style`] on the entire [`Cell`] using [`Cell::style`] or rely on the styling
 /// capabilities of [`Text`].
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
+#[derive(Debug, Clone, PartialEq, Default)]
 pub struct Cell<'a> {
    content: Text<'a>,
    style: Style,
@@ -62,14 +61,14 @@ where
 ///
 /// A [`Row`] is a collection of cells. It can be created from simple strings:
 /// ```rust
-/// # use ratatui::widgets::Row;
+/// # use tui::widgets::Row;
 /// Row::new(vec!["Cell1", "Cell2", "Cell3"]);
 /// ```
 ///
-/// But if you need a bit more control over individual cells, you can explicitly create [`Cell`]s:
+/// But if you need a bit more control over individual cells, you can explicity create [`Cell`]s:
 /// ```rust
-/// # use ratatui::widgets::{Row, Cell};
-/// # use ratatui::style::{Style, Color};
+/// # use tui::widgets::{Row, Cell};
+/// # use tui::style::{Style, Color};
 /// Row::new(vec![
 ///     Cell::from("Cell1"),
 ///     Cell::from("Cell2").style(Style::default().fg(Color::Yellow)),
@@ -79,7 +78,7 @@ where
 /// You can also construct a row from any type that can be converted into [`Text`]:
 /// ```rust
 /// # use std::borrow::Cow;
-/// # use ratatui::widgets::Row;
+/// # use tui::widgets::Row;
 /// Row::new(vec![
 ///     Cow::Borrowed("hello"),
 ///     Cow::Owned("world".to_uppercase()),
@@ -87,7 +86,7 @@ where
 /// ```
 ///
 /// By default, a row has a height of 1 but you can change this using [`Row::height`].
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
+#[derive(Debug, Clone, PartialEq, Default)]
 pub struct Row<'a> {
    cells: Vec<Cell<'a>>,
    height: u16,
@@ -104,7 +103,7 @@ impl<'a> Row<'a> {
    {
        Self {
            height: 1,
-            cells: cells.into_iter().map(Into::into).collect(),
+            cells: cells.into_iter().map(|c| c.into()).collect(),
            style: Style::default(),
            bottom_margin: 0,
        }
@@ -117,7 +116,7 @@ impl<'a> Row<'a> {
        self
    }

-    /// Set the [`Style`] of the entire row. This [`Style`] can be overridden by the [`Style`] of a
+    /// Set the [`Style`] of the entire row. This [`Style`] can be overriden by the [`Style`] of a
    /// any individual [`Cell`] or event by their [`Text`] content.
    pub fn style(mut self, style: Style) -> Self {
        self.style = style;
@@ -140,10 +139,10 @@ impl<'a> Row<'a> {
 ///
 /// It is a collection of [`Row`]s, themselves composed of [`Cell`]s:
 /// ```rust
-/// # use ratatui::widgets::{Block, Borders, Table, Row, Cell};
-/// # use ratatui::layout::Constraint;
-/// # use ratatui::style::{Style, Color, Modifier};
-/// # use ratatui::text::{Text, Line, Span};
+/// # use tui::widgets::{Block, Borders, Table, Row, Cell};
+/// # use tui::layout::Constraint;
+/// # use tui::style::{Style, Color, Modifier};
+/// # use tui::text::{Text, Spans, Span};
 /// Table::new(vec![
 ///     // Row can be created from simple strings.
 ///     Row::new(vec!["Row11", "Row12", "Row13"]),
@@ -153,7 +152,7 @@ impl<'a> Row<'a> {
 ///     Row::new(vec![
 ///         Cell::from("Row31"),
 ///         Cell::from("Row32").style(Style::default().fg(Color::Yellow)),
-///         Cell::from(Line::from(vec![
+///         Cell::from(Spans::from(vec![
 ///             Span::raw("Row"),
 ///             Span::styled("33", Style::default().fg(Color::Green))
 ///         ])),
@@ -187,7 +186,7 @@ impl<'a> Row<'a> {
 /// // ...and potentially show a symbol in front of the selection.
 /// .highlight_symbol(">>");
 /// ```
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Table<'a> {
    /// A block to wrap the widget in
    block: Option<Block<'a>>,
@@ -270,7 +269,8 @@ impl<'a> Table<'a> {
    fn get_columns_widths(&self, max_width: u16, has_selection: bool) -> Vec<u16> {
        let mut constraints = Vec::with_capacity(self.widths.len() * 2 + 1);
        if has_selection {
-            let highlight_symbol_width = self.highlight_symbol.map_or(0, |s| s.width() as u16);
+            let highlight_symbol_width =
+                self.highlight_symbol.map(|s| s.width() as u16).unwrap_or(0);
            constraints.push(Constraint::Length(highlight_symbol_width));
        }
        for constraint in self.widths {
@@ -280,7 +280,7 @@ impl<'a> Table<'a> {
        if !self.widths.is_empty() {
            constraints.pop();
        }
-        let chunks = Layout::default()
+        let mut chunks = Layout::default()
            .direction(Direction::Horizontal)
            .constraints(constraints)
            .expand_to_fill(false)
@@ -290,9 +290,8 @@ impl<'a> Table<'a> {
                width: max_width,
                height: 1,
            });
-        let mut chunks = &chunks[..];
        if has_selection {
-            chunks = &chunks[1..];
+            chunks.remove(0);
        }
        chunks.iter().step_by(2).map(|c| c.width).collect()
    }
@@ -336,31 +335,22 @@ impl<'a> Table<'a> {
    }
 }

-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct TableState {
    offset: usize,
    selected: Option<usize>,
 }

+impl Default for TableState {
+    fn default() -> TableState {
+        TableState {
+            offset: 0,
+            selected: None,
+        }
+    }
+}
+
 impl TableState {
-    pub fn offset(&self) -> usize {
-        self.offset
-    }
-
-    pub fn offset_mut(&mut self) -> &mut usize {
-        &mut self.offset
-    }
-
-    pub fn with_selected(mut self, selected: Option<usize>) -> Self {
-        self.selected = selected;
-        self
-    }
-
-    pub fn with_offset(mut self, offset: usize) -> Self {
-        self.offset = offset;
-        self
-    }
-
    pub fn selected(&self) -> Option<usize> {
        self.selected
    }
@@ -452,7 +442,7 @@ impl<'a> StatefulWidget for Table<'a> {
                height: table_row.height,
            };
            buf.set_style(table_row_area, table_row.style);
-            let is_selected = state.selected.map_or(false, |s| s == i);
+            let is_selected = state.selected.map(|s| s == i).unwrap_or(false);
            let table_row_start_col = if has_selection {
                let symbol = if is_selected {
                    highlight_symbol
@@ -488,11 +478,11 @@ impl<'a> StatefulWidget for Table<'a> {

 fn render_cell(buf: &mut Buffer, cell: &Cell, area: Rect) {
    buf.set_style(area, cell.style);
-    for (i, line) in cell.content.lines.iter().enumerate() {
+    for (i, spans) in cell.content.lines.iter().enumerate() {
        if i as u16 >= area.height {
            break;
        }
-        buf.set_line(area.x, area.y + i as u16, line, area.width);
+        buf.set_spans(area.x, area.y + i as u16, spans, area.width);
    }
 }

--- a/src/widgets/tabs.rs
+++ b/src/widgets/tabs.rs
@@ -3,7 +3,7 @@ use crate::{
    layout::Rect,
    style::Style,
    symbols,
-    text::{Line, Span},
+    text::{Span, Spans},
    widgets::{Block, Widget},
 };

@@ -12,11 +12,11 @@ use crate::{
 /// # Examples
 ///
 /// ```
-/// # use ratatui::widgets::{Block, Borders, Tabs};
-/// # use ratatui::style::{Style, Color};
-/// # use ratatui::text::{Line};
-/// # use ratatui::symbols::{DOT};
-/// let titles = ["Tab1", "Tab2", "Tab3", "Tab4"].iter().cloned().map(Line::from).collect();
+/// # use tui::widgets::{Block, Borders, Tabs};
+/// # use tui::style::{Style, Color};
+/// # use tui::text::{Spans};
+/// # use tui::symbols::{DOT};
+/// let titles = ["Tab1", "Tab2", "Tab3", "Tab4"].iter().cloned().map(Spans::from).collect();
 /// Tabs::new(titles)
 ///     .block(Block::default().title("Tabs").borders(Borders::ALL))
 ///     .style(Style::default().fg(Color::White))
@@ -28,7 +28,7 @@ pub struct Tabs<'a> {
    /// A block to wrap this widget in if necessary
    block: Option<Block<'a>>,
    /// One title for each tab
-    titles: Vec<Line<'a>>,
+    titles: Vec<Spans<'a>>,
    /// The index of the selected tabs
    selected: usize,
    /// The style used to draw the text
@@ -40,16 +40,13 @@ pub struct Tabs<'a> {
 }

 impl<'a> Tabs<'a> {
-    pub fn new<T>(titles: Vec<T>) -> Tabs<'a>
-    where
-        T: Into<Line<'a>>,
-    {
+    pub fn new(titles: Vec<Spans<'a>>) -> Tabs<'a> {
        Tabs {
            block: None,
-            titles: titles.into_iter().map(Into::into).collect(),
+            titles,
            selected: 0,
-            style: Style::default(),
-            highlight_style: Style::default(),
+            style: Default::default(),
+            highlight_style: Default::default(),
            divider: Span::raw(symbols::line::VERTICAL),
        }
    }
@@ -108,7 +105,7 @@ impl<'a> Widget for Tabs<'a> {
            if remaining_width == 0 {
                break;
            }
-            let pos = buf.set_line(x, tabs_area.top(), &title, remaining_width);
+            let pos = buf.set_spans(x, tabs_area.top(), &title, remaining_width);
            if i == self.selected {
                buf.set_style(
                    Rect {
--- a/tests/backend_termion.rs
+++ b/tests/backend_termion.rs
@@ -6,7 +6,7 @@ fn backend_termion_should_only_write_diffs() -> Result<(), Box<dyn std::error::E
    let mut bytes = Vec::new();
    let mut stdout = Cursor::new(&mut bytes);
    {
-        use ratatui::{
+        use tui::{
            backend::TermionBackend, layout::Rect, widgets::Paragraph, Terminal, TerminalOptions,
            Viewport,
        };
@@ -15,7 +15,7 @@ fn backend_termion_should_only_write_diffs() -> Result<(), Box<dyn std::error::E
        let mut terminal = Terminal::with_options(
            backend,
            TerminalOptions {
-                viewport: Viewport::Fixed(area),
+                viewport: Viewport::fixed(area),
            },
        )?;
        terminal.draw(|f| {
--- a/tests/border_macro.rs
+++ b/tests/border_macro.rs
@@ -1,19 +0,0 @@
-#![cfg(feature = "macros")]
-use ratatui::{border, widgets::Borders};
-
-#[test]
-fn border_empty_test() {
-    let empty = Borders::NONE;
-    assert_eq!(empty, border!());
-}
-#[test]
-fn border_all_test() {
-    let all = Borders::ALL;
-    assert_eq!(all, border!(ALL));
-    assert_eq!(all, border!(TOP, BOTTOM, LEFT, RIGHT));
-}
-#[test]
-fn border_left_right_test() {
-    let left_right = Borders::from_bits(Borders::LEFT.bits() | Borders::RIGHT.bits());
-    assert_eq!(left_right, Some(border!(RIGHT, LEFT)));
-}
--- a/tests/stylize.rs
+++ b/tests/stylize.rs
@@ -1,88 +0,0 @@
-use ratatui::{
-    backend::TestBackend,
-    buffer::Buffer,
-    layout::Rect,
-    style::{Color, Stylize},
-    widgets::{Block, Borders, Paragraph},
-    Terminal,
-};
-
-#[test]
-fn paragraph_block_styles() {
-    let backend = TestBackend::new(10, 1);
-    let mut terminal = Terminal::new(backend).unwrap();
-
-    terminal
-        .draw(|f| {
-            let paragraph = Paragraph::new("Text".cyan());
-            f.render_widget(
-                paragraph,
-                Rect {
-                    x: 0,
-                    y: 0,
-                    width: 10,
-                    height: 1,
-                },
-            );
-        })
-        .unwrap();
-
-    let mut expected = Buffer::with_lines(vec!["Text      "]);
-    for x in 0..4 {
-        expected.get_mut(x, 0).set_fg(Color::Cyan);
-    }
-
-    terminal.backend().assert_buffer(&expected);
-}
-
-#[test]
-fn block_styles() {
-    let backend = TestBackend::new(10, 10);
-    let mut terminal = Terminal::new(backend).unwrap();
-
-    terminal
-        .draw(|f| {
-            let block = Block::default()
-                .title("Title".light_blue())
-                .on_cyan()
-                .cyan()
-                .borders(Borders::ALL);
-            f.render_widget(
-                block,
-                Rect {
-                    x: 0,
-                    y: 0,
-                    width: 8,
-                    height: 8,
-                },
-            );
-        })
-        .unwrap();
-
-    let mut expected = Buffer::with_lines(vec![
-        "┌Title─┐  ",
-        "│      │  ",
-        "│      │  ",
-        "│      │  ",
-        "│      │  ",
-        "│      │  ",
-        "│      │  ",
-        "└──────┘  ",
-        "          ",
-        "          ",
-    ]);
-    for x in 0..8 {
-        for y in 0..8 {
-            expected
-                .get_mut(x, y)
-                .set_fg(Color::Cyan)
-                .set_bg(Color::Cyan);
-        }
-    }
-
-    for x in 1..=5 {
-        expected.get_mut(x, 0).set_fg(Color::LightBlue);
-    }
-
-    terminal.backend().assert_buffer(&expected);
-}
--- a/tests/terminal.rs
+++ b/tests/terminal.rs
@@ -1,6 +1,5 @@
 use std::error::Error;
-
-use ratatui::{
+use tui::{
    backend::{Backend, TestBackend},
    layout::Rect,
    widgets::Paragraph,
@@ -16,32 +15,20 @@ fn terminal_buffer_size_should_be_limited() {
    assert_eq!(size.height, 255);
 }

-#[test]
-fn swap_buffer_clears_prev_buffer() {
-    let backend = TestBackend::new(100, 50);
-    let mut terminal = Terminal::new(backend).unwrap();
-    terminal
-        .current_buffer_mut()
-        .set_string(0, 0, "Hello", ratatui::style::Style::reset());
-    assert_eq!(terminal.current_buffer_mut().content()[0].symbol, "H");
-    terminal.swap_buffers();
-    assert_eq!(terminal.current_buffer_mut().content()[0].symbol, " ");
-}
-
 #[test]
 fn terminal_draw_returns_the_completed_frame() -> Result<(), Box<dyn Error>> {
    let backend = TestBackend::new(10, 10);
    let mut terminal = Terminal::new(backend)?;
    let frame = terminal.draw(|f| {
-        let paragraph = Paragraph::new("Test");
-        f.render_widget(paragraph, f.size());
+        let paragrah = Paragraph::new("Test");
+        f.render_widget(paragrah, f.size());
    })?;
    assert_eq!(frame.buffer.get(0, 0).symbol, "T");
    assert_eq!(frame.area, Rect::new(0, 0, 10, 10));
    terminal.backend_mut().resize(8, 8);
    let frame = terminal.draw(|f| {
-        let paragraph = Paragraph::new("test");
-        f.render_widget(paragraph, f.size());
+        let paragrah = Paragraph::new("test");
+        f.render_widget(paragrah, f.size());
    })?;
    assert_eq!(frame.buffer.get(0, 0).symbol, "t");
    assert_eq!(frame.area, Rect::new(0, 0, 8, 8));
--- a/tests/widgets_barchart.rs
+++ b/tests/widgets_barchart.rs
@@ -1,9 +1,7 @@
-use ratatui::{
-    backend::TestBackend,
-    buffer::Buffer,
-    widgets::{BarChart, Block, Borders},
-    Terminal,
-};
+use tui::backend::TestBackend;
+use tui::buffer::Buffer;
+use tui::widgets::{BarChart, Block, Borders};
+use tui::Terminal;

 #[test]
 fn widgets_barchart_not_full_below_max_value() {
--- a/tests/widgets_block.rs
+++ b/tests/widgets_block.rs
@@ -1,13 +1,10 @@
-use ratatui::{
+use tui::{
    backend::TestBackend,
    buffer::Buffer,
    layout::{Alignment, Rect},
    style::{Color, Style},
    text::Span,
-    widgets::{
-        block::title::{Position, Title},
-        Block, Borders,
-    },
+    widgets::{Block, Borders},
    Terminal,
 };

@@ -49,80 +46,6 @@ fn widgets_block_renders() {
    terminal.backend().assert_buffer(&expected);
 }

-#[test]
-fn widgets_block_titles_overlap() {
-    let test_case = |block, area: Rect, expected| {
-        let backend = TestBackend::new(area.width, area.height);
-        let mut terminal = Terminal::new(backend).unwrap();
-        terminal
-            .draw(|f| {
-                f.render_widget(block, area);
-            })
-            .unwrap();
-        terminal.backend().assert_buffer(&expected);
-    };
-
-    // Left overrides the center
-    test_case(
-        Block::default()
-            .title(Title::from("aaaaa").alignment(Alignment::Left))
-            .title(Title::from("bbb").alignment(Alignment::Center))
-            .title(Title::from("ccc").alignment(Alignment::Right)),
-        Rect {
-            x: 0,
-            y: 0,
-            width: 10,
-            height: 1,
-        },
-        Buffer::with_lines(vec!["aaaaab ccc"]),
-    );
-
-    // Left alignment overrides the center alignment which overrides the right alignment
-    test_case(
-        Block::default()
-            .title(Title::from("aaaaa").alignment(Alignment::Left))
-            .title(Title::from("bbbbb").alignment(Alignment::Center))
-            .title(Title::from("ccccc").alignment(Alignment::Right)),
-        Rect {
-            x: 0,
-            y: 0,
-            width: 11,
-            height: 1,
-        },
-        Buffer::with_lines(vec!["aaaaabbbccc"]),
-    );
-
-    // Multiple left alignment overrides the center alignment and the right alignment
-    test_case(
-        Block::default()
-            .title(Title::from("aaaaa").alignment(Alignment::Left))
-            .title(Title::from("aaaaa").alignment(Alignment::Left))
-            .title(Title::from("bbbbb").alignment(Alignment::Center))
-            .title(Title::from("ccccc").alignment(Alignment::Right)),
-        Rect {
-            x: 0,
-            y: 0,
-            width: 11,
-            height: 1,
-        },
-        Buffer::with_lines(vec!["aaaaabaaaaa"]),
-    );
-
-    // The right alignment doesn't override the center alignment, but pierces through it
-    test_case(
-        Block::default()
-            .title(Title::from("bbbbb").alignment(Alignment::Center))
-            .title(Title::from("ccccccccccc").alignment(Alignment::Right)),
-        Rect {
-            x: 0,
-            y: 0,
-            width: 11,
-            height: 1,
-        },
-        Buffer::with_lines(vec!["cccbbbbbccc"]),
-    );
-}
-
 #[test]
 fn widgets_block_renders_on_small_areas() {
    let test_case = |block, area: Rect, expected| {
@@ -296,7 +219,8 @@ fn widgets_block_title_alignment() {
        let mut terminal = Terminal::new(backend).unwrap();

        let block = Block::default()
-            .title(Title::from(Span::styled("Title", Style::default())).alignment(alignment))
+            .title(Span::styled("Title", Style::default()))
+            .title_alignment(alignment)
            .borders(borders);

        let area = Rect {
@@ -420,287 +344,3 @@ fn widgets_block_title_alignment() {
        Buffer::with_lines(vec!["         Title ", "               "]),
    );
 }
-
-#[test]
-fn widgets_block_title_alignment_bottom() {
-    let test_case = |alignment, borders, expected| {
-        let backend = TestBackend::new(15, 2);
-        let mut terminal = Terminal::new(backend).unwrap();
-
-        let block = Block::default()
-            .title(
-                Title::from(Span::styled("Title", Style::default()))
-                    .alignment(alignment)
-                    .position(Position::Bottom),
-            )
-            .borders(borders);
-
-        let area = Rect {
-            x: 1,
-            y: 0,
-            width: 13,
-            height: 2,
-        };
-
-        terminal
-            .draw(|f| {
-                f.render_widget(block, area);
-            })
-            .unwrap();
-
-        terminal.backend().assert_buffer(&expected);
-    };
-
-    // title bottom-left with all borders
-    test_case(
-        Alignment::Left,
-        Borders::ALL,
-        Buffer::with_lines(vec![" ┌───────────┐ ", " └Title──────┘ "]),
-    );
-
-    // title bottom-left without bottom border
-    test_case(
-        Alignment::Left,
-        Borders::LEFT | Borders::TOP | Borders::RIGHT,
-        Buffer::with_lines(vec![" ┌───────────┐ ", " │Title      │ "]),
-    );
-
-    // title bottom-left with no left border
-    test_case(
-        Alignment::Left,
-        Borders::TOP | Borders::RIGHT | Borders::BOTTOM,
-        Buffer::with_lines(vec![" ────────────┐ ", " Title───────┘ "]),
-    );
-
-    // title bottom-left without right border
-    test_case(
-        Alignment::Left,
-        Borders::LEFT | Borders::TOP | Borders::BOTTOM,
-        Buffer::with_lines(vec![" ┌──────────── ", " └Title─────── "]),
-    );
-
-    // title bottom-left without borders
-    test_case(
-        Alignment::Left,
-        Borders::NONE,
-        Buffer::with_lines(vec!["               ", " Title         "]),
-    );
-
-    // title center with all borders
-    test_case(
-        Alignment::Center,
-        Borders::ALL,
-        Buffer::with_lines(vec![" ┌───────────┐ ", " └───Title───┘ "]),
-    );
-
-    // title center without bottom border
-    test_case(
-        Alignment::Center,
-        Borders::LEFT | Borders::TOP | Borders::RIGHT,
-        Buffer::with_lines(vec![" ┌───────────┐ ", " │   Title   │ "]),
-    );
-
-    // title center with no left border
-    test_case(
-        Alignment::Center,
-        Borders::TOP | Borders::RIGHT | Borders::BOTTOM,
-        Buffer::with_lines(vec![" ────────────┐ ", " ────Title───┘ "]),
-    );
-
-    // title center without right border
-    test_case(
-        Alignment::Center,
-        Borders::LEFT | Borders::TOP | Borders::BOTTOM,
-        Buffer::with_lines(vec![" ┌──────────── ", " └───Title──── "]),
-    );
-
-    // title center without borders
-    test_case(
-        Alignment::Center,
-        Borders::NONE,
-        Buffer::with_lines(vec!["               ", "     Title     "]),
-    );
-
-    // title bottom-right with all borders
-    test_case(
-        Alignment::Right,
-        Borders::ALL,
-        Buffer::with_lines(vec![" ┌───────────┐ ", " └──────Title┘ "]),
-    );
-
-    // title bottom-right without bottom border
-    test_case(
-        Alignment::Right,
-        Borders::LEFT | Borders::TOP | Borders::RIGHT,
-        Buffer::with_lines(vec![" ┌───────────┐ ", " │      Title│ "]),
-    );
-
-    // title bottom-right with no left border
-    test_case(
-        Alignment::Right,
-        Borders::TOP | Borders::RIGHT | Borders::BOTTOM,
-        Buffer::with_lines(vec![" ────────────┐ ", " ───────Title┘ "]),
-    );
-
-    // title bottom-right without right border
-    test_case(
-        Alignment::Right,
-        Borders::LEFT | Borders::TOP | Borders::BOTTOM,
-        Buffer::with_lines(vec![" ┌──────────── ", " └───────Title "]),
-    );
-
-    // title bottom-right without borders
-    test_case(
-        Alignment::Right,
-        Borders::NONE,
-        Buffer::with_lines(vec!["               ", "         Title "]),
-    );
-}
-
-#[test]
-fn widgets_block_multiple_titles() {
-    let test_case = |title_a, title_b, borders, expected| {
-        let backend = TestBackend::new(15, 2);
-        let mut terminal = Terminal::new(backend).unwrap();
-
-        let block = Block::default()
-            .title(title_a)
-            .title(title_b)
-            .borders(borders);
-
-        let area = Rect {
-            x: 1,
-            y: 0,
-            width: 13,
-            height: 2,
-        };
-
-        terminal
-            .draw(|f| {
-                f.render_widget(block, area);
-            })
-            .unwrap();
-
-        terminal.backend().assert_buffer(&expected);
-    };
-
-    // title bottom-left with all borders
-    test_case(
-        Title::from("foo"),
-        Title::from("bar"),
-        Borders::ALL,
-        Buffer::with_lines(vec![" ┌foo─bar────┐ ", " └───────────┘ "]),
-    );
-
-    // title top-left without top border
-    test_case(
-        Title::from("foo"),
-        Title::from("bar"),
-        Borders::LEFT | Borders::BOTTOM | Borders::RIGHT,
-        Buffer::with_lines(vec![" │foo bar    │ ", " └───────────┘ "]),
-    );
-
-    // title top-left with no left border
-    test_case(
-        Title::from("foo"),
-        Title::from("bar"),
-        Borders::TOP | Borders::RIGHT | Borders::BOTTOM,
-        Buffer::with_lines(vec![" foo─bar─────┐ ", " ────────────┘ "]),
-    );
-
-    // title top-left without right border
-    test_case(
-        Title::from("foo"),
-        Title::from("bar"),
-        Borders::LEFT | Borders::TOP | Borders::BOTTOM,
-        Buffer::with_lines(vec![" ┌foo─bar───── ", " └──────────── "]),
-    );
-
-    // title top-left without borders
-    test_case(
-        Title::from("foo"),
-        Title::from("bar"),
-        Borders::NONE,
-        Buffer::with_lines(vec![" foo bar      ", "               "]),
-    );
-
-    // title center with all borders
-    test_case(
-        Title::from("foo").alignment(Alignment::Center),
-        Title::from("bar").alignment(Alignment::Center),
-        Borders::ALL,
-        Buffer::with_lines(vec![" ┌──foo─bar──┐ ", " └───────────┘ "]),
-    );
-
-    // title center without top border
-    test_case(
-        Title::from("foo").alignment(Alignment::Center),
-        Title::from("bar").alignment(Alignment::Center),
-        Borders::LEFT | Borders::BOTTOM | Borders::RIGHT,
-        Buffer::with_lines(vec![" │  foo bar  │ ", " └───────────┘ "]),
-    );
-
-    // title center with no left border
-    test_case(
-        Title::from("foo").alignment(Alignment::Center),
-        Title::from("bar").alignment(Alignment::Center),
-        Borders::TOP | Borders::RIGHT | Borders::BOTTOM,
-        Buffer::with_lines(vec![" ───foo─bar──┐ ", " ────────────┘ "]),
-    );
-
-    // title center without right border
-    test_case(
-        Title::from("foo").alignment(Alignment::Center),
-        Title::from("bar").alignment(Alignment::Center),
-        Borders::LEFT | Borders::TOP | Borders::BOTTOM,
-        Buffer::with_lines(vec![" ┌──foo─bar─── ", " └──────────── "]),
-    );
-
-    // title center without borders
-    test_case(
-        Title::from("foo").alignment(Alignment::Center),
-        Title::from("bar").alignment(Alignment::Center),
-        Borders::NONE,
-        Buffer::with_lines(vec!["    foo bar    ", "               "]),
-    );
-
-    // title top-right with all borders
-    test_case(
-        Title::from("foo").alignment(Alignment::Right),
-        Title::from("bar").alignment(Alignment::Right),
-        Borders::ALL,
-        Buffer::with_lines(vec![" ┌────foo─bar┐ ", " └───────────┘ "]),
-    );
-
-    // title top-right without top border
-    test_case(
-        Title::from("foo").alignment(Alignment::Right),
-        Title::from("bar").alignment(Alignment::Right),
-        Borders::LEFT | Borders::BOTTOM | Borders::RIGHT,
-        Buffer::with_lines(vec![" │    foo bar│ ", " └───────────┘ "]),
-    );
-
-    // title top-right with no left border
-    test_case(
-        Title::from("foo").alignment(Alignment::Right),
-        Title::from("bar").alignment(Alignment::Right),
-        Borders::TOP | Borders::RIGHT | Borders::BOTTOM,
-        Buffer::with_lines(vec![" ─────foo─bar┐ ", " ────────────┘ "]),
-    );
-
-    // title top-right without right border
-    test_case(
-        Title::from("foo").alignment(Alignment::Right),
-        Title::from("bar").alignment(Alignment::Right),
-        Borders::LEFT | Borders::TOP | Borders::BOTTOM,
-        Buffer::with_lines(vec![" ┌─────foo─bar ", " └──────────── "]),
-    );
-
-    // title top-right without borders
-    test_case(
-        Title::from("foo").alignment(Alignment::Right),
-        Title::from("bar").alignment(Alignment::Right),
-        Borders::NONE,
-        Buffer::with_lines(vec!["       foo bar ", "               "]),
-    );
-}
--- a/tests/widgets_calendar.rs
+++ b/tests/widgets_calendar.rs
@@ -1,113 +0,0 @@
-#![cfg(feature = "widget-calendar")]
-use ratatui::{
-    backend::TestBackend,
-    buffer::Buffer,
-    style::Style,
-    widgets::{
-        calendar::{CalendarEventStore, Monthly},
-        Widget,
-    },
-    Terminal,
-};
-use time::{Date, Month};
-
-fn test_render<W: Widget>(widget: W, expected: Buffer, size: (u16, u16)) {
-    let backend = TestBackend::new(size.0, size.1);
-    let mut terminal = Terminal::new(backend).unwrap();
-
-    terminal
-        .draw(|f| f.render_widget(widget, f.size()))
-        .unwrap();
-    terminal.backend().assert_buffer(&expected);
-}
-
-#[test]
-fn days_layout() {
-    let c = Monthly::new(
-        Date::from_calendar_date(2023, Month::January, 1).unwrap(),
-        CalendarEventStore::default(),
-    );
-    let expected = Buffer::with_lines(vec![
-        "  1  2  3  4  5  6  7",
-        "  8  9 10 11 12 13 14",
-        " 15 16 17 18 19 20 21",
-        " 22 23 24 25 26 27 28",
-        " 29 30 31",
-    ]);
-    test_render(c, expected, (21, 5));
-}
-
-#[test]
-fn days_layout_show_surrounding() {
-    let c = Monthly::new(
-        Date::from_calendar_date(2023, Month::December, 1).unwrap(),
-        CalendarEventStore::default(),
-    )
-    .show_surrounding(Style::default());
-    let expected = Buffer::with_lines(vec![
-        " 26 27 28 29 30  1  2",
-        "  3  4  5  6  7  8  9",
-        " 10 11 12 13 14 15 16",
-        " 17 18 19 20 21 22 23",
-        " 24 25 26 27 28 29 30",
-        " 31  1  2  3  4  5  6",
-    ]);
-    test_render(c, expected, (21, 6));
-}
-
-#[test]
-fn show_month_header() {
-    let c = Monthly::new(
-        Date::from_calendar_date(2023, Month::January, 1).unwrap(),
-        CalendarEventStore::default(),
-    )
-    .show_month_header(Style::default());
-    let expected = Buffer::with_lines(vec![
-        "     January 2023    ",
-        "  1  2  3  4  5  6  7",
-        "  8  9 10 11 12 13 14",
-        " 15 16 17 18 19 20 21",
-        " 22 23 24 25 26 27 28",
-        " 29 30 31",
-    ]);
-    test_render(c, expected, (21, 6));
-}
-
-#[test]
-fn show_weekdays_header() {
-    let c = Monthly::new(
-        Date::from_calendar_date(2023, Month::January, 1).unwrap(),
-        CalendarEventStore::default(),
-    )
-    .show_weekdays_header(Style::default());
-    let expected = Buffer::with_lines(vec![
-        " Su Mo Tu We Th Fr Sa",
-        "  1  2  3  4  5  6  7",
-        "  8  9 10 11 12 13 14",
-        " 15 16 17 18 19 20 21",
-        " 22 23 24 25 26 27 28",
-        " 29 30 31",
-    ]);
-    test_render(c, expected, (21, 6));
-}
-
-#[test]
-fn show_combo() {
-    let c = Monthly::new(
-        Date::from_calendar_date(2023, Month::January, 1).unwrap(),
-        CalendarEventStore::default(),
-    )
-    .show_weekdays_header(Style::default())
-    .show_month_header(Style::default())
-    .show_surrounding(Style::default());
-    let expected = Buffer::with_lines(vec![
-        "     January 2023    ",
-        " Su Mo Tu We Th Fr Sa",
-        "  1  2  3  4  5  6  7",
-        "  8  9 10 11 12 13 14",
-        " 15 16 17 18 19 20 21",
-        " 22 23 24 25 26 27 28",
-        " 29 30 31  1  2  3  4",
-    ]);
-    test_render(c, expected, (21, 7));
-}
--- a/tests/widgets_canvas.rs
+++ b/tests/widgets_canvas.rs
@@ -1,42 +0,0 @@
-use ratatui::{
-    backend::TestBackend,
-    buffer::Buffer,
-    style::{Color, Style},
-    text::Span,
-    widgets::canvas::Canvas,
-    Terminal,
-};
-
-#[test]
-fn widgets_canvas_draw_labels() {
-    let backend = TestBackend::new(5, 5);
-    let mut terminal = Terminal::new(backend).unwrap();
-    terminal
-        .draw(|f| {
-            let label = String::from("test");
-            let canvas = Canvas::default()
-                .background_color(Color::Yellow)
-                .x_bounds([0.0, 5.0])
-                .y_bounds([0.0, 5.0])
-                .paint(|ctx| {
-                    ctx.print(
-                        0.0,
-                        0.0,
-                        Span::styled(label.clone(), Style::default().fg(Color::Blue)),
-                    );
-                });
-            f.render_widget(canvas, f.size());
-        })
-        .unwrap();
-
-    let mut expected = Buffer::with_lines(vec!["    ", "    ", "     ", "     ", "test "]);
-    for row in 0..5 {
-        for col in 0..5 {
-            expected.get_mut(col, row).set_bg(Color::Yellow);
-        }
-    }
-    for col in 0..4 {
-        expected.get_mut(col, 4).set_fg(Color::Blue);
-    }
-    terminal.backend().assert_buffer(&expected);
-}
--- a/tests/widgets_chart.rs
+++ b/tests/widgets_chart.rs
@@ -1,7 +1,7 @@
-use ratatui::{
+use tui::{
    backend::TestBackend,
    buffer::Buffer,
-    layout::{Alignment, Rect},
+    layout::Rect,
    style::{Color, Style},
    symbols,
    text::Span,
@@ -13,22 +13,6 @@ fn create_labels<'a>(labels: &'a [&'a str]) -> Vec<Span<'a>> {
    labels.iter().map(|l| Span::from(*l)).collect()
 }

-fn axis_test_case<S>(width: u16, height: u16, x_axis: Axis, y_axis: Axis, lines: Vec<S>)
-where
-    S: AsRef<str>,
-{
-    let backend = TestBackend::new(width, height);
-    let mut terminal = Terminal::new(backend).unwrap();
-    terminal
-        .draw(|f| {
-            let chart = Chart::new(vec![]).x_axis(x_axis).y_axis(y_axis);
-            f.render_widget(chart, f.size());
-        })
-        .unwrap();
-    let expected = Buffer::with_lines(lines);
-    terminal.backend().assert_buffer(&expected);
-}
-
 #[test]
 fn widgets_chart_can_render_on_small_areas() {
    let test_case = |width, height| {
@@ -65,26 +49,33 @@ fn widgets_chart_can_render_on_small_areas() {

 #[test]
 fn widgets_chart_handles_long_labels() {
-    let test_case = |x_labels, y_labels, x_alignment, lines| {
-        let mut x_axis = Axis::default().bounds([0.0, 1.0]);
-        if let Some((left_label, right_label)) = x_labels {
-            x_axis = x_axis
-                .labels(vec![Span::from(left_label), Span::from(right_label)])
-                .labels_alignment(x_alignment);
-        }
-
-        let mut y_axis = Axis::default().bounds([0.0, 1.0]);
-        if let Some((left_label, right_label)) = y_labels {
-            y_axis = y_axis.labels(vec![Span::from(left_label), Span::from(right_label)]);
-        }
-
-        axis_test_case(10, 5, x_axis, y_axis, lines);
+    let test_case = |x_labels, y_labels, lines| {
+        let backend = TestBackend::new(10, 5);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal
+            .draw(|f| {
+                let datasets = vec![Dataset::default()
+                    .marker(symbols::Marker::Braille)
+                    .style(Style::default().fg(Color::Magenta))
+                    .data(&[(2.0, 2.0)])];
+                let mut x_axis = Axis::default().bounds([0.0, 1.0]);
+                if let Some((left_label, right_label)) = x_labels {
+                    x_axis = x_axis.labels(vec![Span::from(left_label), Span::from(right_label)]);
+                }
+                let mut y_axis = Axis::default().bounds([0.0, 1.0]);
+                if let Some((left_label, right_label)) = y_labels {
+                    y_axis = y_axis.labels(vec![Span::from(left_label), Span::from(right_label)]);
+                }
+                let chart = Chart::new(datasets).x_axis(x_axis).y_axis(y_axis);
+                f.render_widget(chart, f.size());
+            })
+            .unwrap();
+        let expected = Buffer::with_lines(lines);
+        terminal.backend().assert_buffer(&expected);
    };
-
    test_case(
        Some(("AAAA", "B")),
        None,
-        Alignment::Left,
        vec![
            "          ",
            "          ",
@@ -96,7 +87,6 @@ fn widgets_chart_handles_long_labels() {
    test_case(
        Some(("A", "BBBB")),
        None,
-        Alignment::Left,
        vec![
            "          ",
            "          ",
@@ -108,7 +98,6 @@ fn widgets_chart_handles_long_labels() {
    test_case(
        Some(("AAAAAAAAAAA", "B")),
        None,
-        Alignment::Left,
        vec![
            "          ",
            "          ",
@@ -120,7 +109,6 @@ fn widgets_chart_handles_long_labels() {
    test_case(
        Some(("A", "B")),
        Some(("CCCCCCC", "D")),
-        Alignment::Left,
        vec![
            "D  │      ",
            "   │      ",
@@ -129,129 +117,6 @@ fn widgets_chart_handles_long_labels() {
            "   A     B",
        ],
    );
-    test_case(
-        Some(("AAAAAAAAAA", "B")),
-        Some(("C", "D")),
-        Alignment::Center,
-        vec![
-            "D  │      ",
-            "   │      ",
-            "C  │      ",
-            "   └──────",
-            "AAAAAAA  B",
-        ],
-    );
-    test_case(
-        Some(("AAAAAAA", "B")),
-        Some(("C", "D")),
-        Alignment::Right,
-        vec![
-            "D│        ",
-            " │        ",
-            "C│        ",
-            " └────────",
-            " AAAAA   B",
-        ],
-    );
-    test_case(
-        Some(("AAAAAAA", "BBBBBBB")),
-        Some(("C", "D")),
-        Alignment::Right,
-        vec![
-            "D│        ",
-            " │        ",
-            "C│        ",
-            " └────────",
-            " AAAAABBBB",
-        ],
-    );
-}
-
-#[test]
-fn widgets_chart_handles_x_axis_labels_alignments() {
-    let test_case = |y_alignment, lines| {
-        let x_axis = Axis::default()
-            .labels(vec![Span::from("AAAA"), Span::from("B"), Span::from("C")])
-            .labels_alignment(y_alignment);
-
-        let y_axis = Axis::default();
-
-        axis_test_case(10, 5, x_axis, y_axis, lines);
-    };
-
-    test_case(
-        Alignment::Left,
-        vec![
-            "          ",
-            "          ",
-            "          ",
-            "   ───────",
-            "AAA   B  C",
-        ],
-    );
-    test_case(
-        Alignment::Center,
-        vec![
-            "          ",
-            "          ",
-            "          ",
-            "  ────────",
-            "AAAA B   C",
-        ],
-    );
-    test_case(
-        Alignment::Right,
-        vec![
-            "          ",
-            "          ",
-            "          ",
-            "──────────",
-            "AAA  B   C",
-        ],
-    );
-}
-
-#[test]
-fn widgets_chart_handles_y_axis_labels_alignments() {
-    let test_case = |y_alignment, lines| {
-        let x_axis = Axis::default().labels(create_labels(&["AAAAA", "B"]));
-
-        let y_axis = Axis::default()
-            .labels(create_labels(&["C", "D"]))
-            .labels_alignment(y_alignment);
-
-        axis_test_case(20, 5, x_axis, y_axis, lines);
-    };
-    test_case(
-        Alignment::Left,
-        vec![
-            "D   │               ",
-            "    │               ",
-            "C   │               ",
-            "    └───────────────",
-            "AAAAA              B",
-        ],
-    );
-    test_case(
-        Alignment::Center,
-        vec![
-            "  D │               ",
-            "    │               ",
-            "  C │               ",
-            "    └───────────────",
-            "AAAAA              B",
-        ],
-    );
-    test_case(
-        Alignment::Right,
-        vec![
-            "   D│               ",
-            "    │               ",
-            "   C│               ",
-            "    └───────────────",
-            "AAAAA              B",
-        ],
-    );
 }

 #[test]
@@ -464,11 +329,11 @@ fn widgets_chart_can_have_a_legend() {
        "│    │ ••                                               •• │",
        "│0.0 │•                                              X Axis│",
        "│    └─────────────────────────────────────────────────────│",
-        "│  0.0                        50.0                    100.0│",
+        "│  0.0                      50.0                     100.0 │",
        "└──────────────────────────────────────────────────────────┘",
    ]);

-    // Set expected background color
+    // Set expected backgound color
    for row in 0..30 {
        for col in 0..60 {
            expected.get_mut(col, row).set_bg(Color::White);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
philippeitis	7a4897d2b3	Add backwards fill	2021-10-15 11:33:53 -07:00
philippeitis	0dc25e7c2a	Remove target entirely	2021-10-15 11:12:59 -07:00
philippeitis	57389c5b55	Allow user to specify offset directly	2021-10-15 11:12:14 -07:00
philippeitis	a7202307ae	Remove duplicate impl block	2021-10-15 10:52:18 -07:00
philippeitis	0c0c396c61	Create List with multiple selections	2021-10-15 10:48:12 -07:00