# mirador, fourteen panels and exactly one at full brightness

> mirador is a Rust and ratatui terminal dashboard built around a single constraint: it lives in a tab you leave open all day and glance at, so nothing blinks and everything except the focused panel is dimmed. Its data is TOML you can put in git, its update check is off by default, and its author states plainly that the code was written with heavy AI assistance and then shows you the CI that holds it to account.

**jchultarsky/mirador** — An opinionated personal dashboard for your terminal — world clocks, calendar and agenda, weather, tasks, notes, markets and live system metrics in a tab you leave open all day. Rust + ratatui.

- Repository: https://github.com/jchultarsky/mirador
- Website: https://crates.io/crates/mirador
- Stars: 320 · Forks: 33
- Language: Rust
- License: MIT
- Published: 2026-09-18 · Updated: 2026-09-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/jchultarsky-mirador

## Fourteen panels and one of them at full brightness

A first run opens fourteen panels on a grid sized 200 by 50, and the layout assumes nothing has to fall back to a narrower form.

The panels cover world clocks, a calendar and agenda, weather, a task list, notes, a market watchlist, and live CPU and network charts. A calculator is present too, described in detail: three sums, each answer appearing in the right-hand column as it is typed, and Enter feeding it up a tape where results line up on their decimal points.

The focus model is the part that makes a dense grid readable. The lit frame is the focused panel and it carries its own key hints in its bottom border. Every other panel is dimmed, so exactly one thing is at full brightness at a time. Focus moves with Tab.

Layout is editable at runtime. The w key opens a panel picker and switching a panel off closes the grid over the gap rather than leaving an empty cell. The m key starts arranging, moving the selected panel along its row, up into the row above, and past the top edge into a row of its own, with the real panels moving as the keys are pressed and Escape putting everything back.

A question mark lists every binding for the focused panel, and scrolls when there are more bindings than fit.

## Built to be glanced at rather than watched

The README opens with a design constraint and then applies it to everything.

The claim is that most terminal dashboards are built to be watched, the kind you open when something is wrong, dense and busy and refreshing as fast as it can. mirador is built to be glanced at: one tab, all day, in the corner of your eye. Nothing blinks or shimmers. Unfocused panels dim.

The interaction detail that follows from that is worth naming. A notice retires on your first keypress, with the reasoning stated plainly: a dashboard that nags is a dashboard you close.

The name is the same idea. A mirador is a lookout, the tower you climb to see everything at once, and the project uses fourteen panels on one screen as the argument for the metaphor rather than as decoration.

There is one more editorial decision in the demo section that says a lot about the project. The tasks and the note in the recorded session are examples the tool seeds on a first run. The weather, the prices, and the graphs are simply whatever was true while the recording was made, driven by a script in the docs directory that runs a real build under tmux. The one thing deliberately staged is the calendar, because the project states it never invents one, and without a sample the agenda panel would spend the whole recording explaining how to point it at a file. Inventing data would have made the demo smoother and the tool less honest.

## Your data is TOML you can put in git

The storage decision is stated as a list of things the project does not do, and the list is specific.

Tasks, notes, and the watchlist are plain TOML. There is no database, no sync service, no account, no API key, and no telemetry. Nothing phones home unless asked to. The files can be hand-edited, kept in git, or deleted.

That is an unusual set of constraints for a dashboard that fetches weather and prices, and the README pre-empts the obvious objection by separating the two behaviours. The three network panels fetch the data their panels exist to show, which is not the same as phoning home: nothing is sent about you. And switching a panel off with w stops its requests entirely, which is the part most dashboards of this kind do not offer.

The task list gets its own paragraph because the author considers it the panel most dashboards treat as a checkbox. It has due dates, priorities, notes, tags, filtering, and full editing without leaving the dashboard.

The dependency list backs up the no-runtime claim. Thirteen crates, no async runtime and no async HTTP client, which for a full-screen terminal application means there is no event loop to reason about. Time handling, XML parsing for feeds, character width measurement for layout, configuration directories, TOML, and serialisation are each one small crate.

## Three endpoints, no keys, and an off switch

The network surface is small enough to enumerate, which is unusual and convenient.

Weather comes from Open-Meteo. Prices come from Yahoo's public chart endpoint. News comes from whatever RSS feeds you configure. All three are described as free and key-less, which is what removes the account requirement from the privacy story.

The shipped news feeds are three: NASA, Phys.org, and Ars Technica. They live in a news section of the configuration and the README says to change them or empty them, so a user who wants no news at all removes the list rather than suppressing output.

The prices endpoint gets its own qualification. The README calls it Yahoo's public chart endpoint and points to a dedicated Market data section for what that means in practice, which is a careful way of saying the endpoint is not a documented contract and that the section explains the consequences. It is the one of the three whose long-term stability is not the platform's to promise.

Configuration is TOML throughout, with the general section holding settings such as the update check and the news section holding the feed list. Keys are dotted paths in square brackets, which reads cleanly and keeps the file hand-editable.

## One installer verifies the archive and the other does not

The install section is candid about an asymmetry between two platforms, and it says whose behaviour it is.

With Rust, the install is cargo install mirador. Without it, macOS and Linux get a shell installer piped from the GitHub releases page, and Windows gets the PowerShell equivalent:

```sh
cargo install mirador
```

Both fetch the archive for your platform and unpack the binary, and both are ordinary files you can read at that URL before running.

Then the caveat. The shell installer checks the archive against its published sha256. The PowerShell one does no verification. Neither verifies the updater binary. The README attributes this to the release tooling it uses rather than to the project, and points at its own security document for what the checking does and does not buy you.

It also offers the stronger check, which is a GitHub provenance attestation on every artifact, verified with the gh command against a named release file.

Upgrades go through a mirador --update flag, which hands an installer-managed copy to a helper program placed beside it and a crates.io copy back to Cargo. A binary extracted from an archive has no installation record to follow, so the README says to update it manually or run an installer once. That last case is the one people hit by accident.

## The release profile is overridden on purpose

One of the most informative comments in the project sits in the build file, explaining a setting that does nothing except prevent a future change.

The release profile uses fat LTO, a single codegen unit, and symbol stripping. A separate profile exists for the release tooling, and instead of writing its own settings it inherits the release profile unchanged. The comment explains why: the tooling's own initialisation would write a thin LTO setting there, which would quietly undo fat LTO. Every release so far was built with the fat setting because the previous pipeline invoked the release build directly, and there is no reason for the binaries to get slower on the release where that pipeline starts being used.

The stated cost is build time in continuous integration, and the comment closes by noting nobody is waiting on it. That is the whole argument for the override, and it is the kind of decision that is invisible until someone runs an init command without reading it.

Two other settings in the same file are worth knowing. Unsafe code is forbidden outright at the lint level rather than warned about, which is a stronger position than most projects take. And the published crate excludes the workflows directory, the documentation directory, and image files, so a crate download is smaller than a repository clone.

## The author credits Claude and then points at the CI

The project states how it was written before describing a single feature, which is not a common choice.

The README says the implementation, the tests, and most of the documentation were written by Claude, working from the author's direction and review, and that the product decisions are the author's. It gives the reason plainly: anyone evaluating the code deserves to know how it was made, and some communities reasonably want to know before adopting or recommending something. It also says explicitly that this is not a claim about quality in either direction.

Then it answers the obvious follow-up by listing what to weigh instead. Every change lands through continuous integration that runs the test suite on macOS, Linux, and Windows, plus the linter with warnings denied, the documentation builder with warnings denied, a minimum supported Rust version check, a publish dry run, and a dependency audit covering advisories, licences, and sources.

The claim about test quality is the specific one. Behavioural claims in the commit history are described as measured rather than asserted, with several fixes verified by reverting them to confirm the new test actually failed when the bug was present. Two tests in the repository were found to be pinning the very bug they existed to catch, and the author says so rather than quietly fixing them.

Design decisions and the reasoning behind them, including the ones that were reversed and why, live in a dedicated file rather than in commit messages.

## Conclusion

mirador suits someone who wants a persistent status tab rather than a monitor they open when something breaks, and who is willing to own plain files instead of an account. Check four things first. Whether your terminal is wide enough for the default layout, since the design assumes a 200 by 50 grid. Whether you are on Rust edition 2024 with 1.95 or newer. Whether you installed through an installer or straight from an archive, because the built-in update path follows an installation record and an extracted binary has none. And whether the update check is acceptable to you at all, since it is off until you turn it on and can be disabled outright by environment variable.

## FAQ

### What is mirador?

It is an opinionated personal dashboard for a terminal, written in Rust with ratatui. Fourteen panels open on a first run at a 200 by 50 grid, covering world clocks, a calendar and agenda, weather, tasks, notes, a market watchlist, and live CPU and network charts.

### How do I install mirador?

With cargo install mirador if you have Rust. Without Rust, macOS and Linux use a shell installer piped from the GitHub releases page and Windows uses the PowerShell equivalent. A later upgrade is the mirador --update flag.

### Does mirador phone home or collect telemetry?

The README states no database, sync service, account, API key, or telemetry. Update checks are off by default, send no identifier, cache their answer, fail silently, and are overridden by NO_UPDATE_CHECK=1 or DO_NOT_TRACK=1 in the environment.

### What does mirador need to build and run?

Rust edition 2024 with a rust-version floor of 1.95, and thirteen runtime dependencies with no async runtime among them. Unsafe code is forbidden at the lint level, and the release profile uses fat LTO with a single codegen unit and stripped symbols.

## Sources

- [jchultarsky/mirador on GitHub](https://github.com/jchultarsky/mirador)
- [License: MIT](https://github.com/jchultarsky/mirador/blob/main/LICENSE)
- [Project website](https://crates.io/crates/mirador)
- [README](https://github.com/jchultarsky/mirador/blob/main/README.md)
- [Releases](https://github.com/jchultarsky/mirador/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jchultarsky-mirador