wtfutil.com

WTF (wtfutil.com) is a personal information dashboard that runs in your terminal, and its module list is broad: it covers developer tooling (Git, GitHub, GitLab, Jenkins, TravisCI), monitoring and on-call services (Datadog, PagerDuty, UptimeRobot, OpsGenie, New Relic), and everyday widgets such as clocks, weather, stocks, crypto prices, and feed readers. Each module appears in the documentation with its own settings, so the practical answer to "what can it show?" is "whatever module you enable and configure in your config file." The condition: you need a terminal environment and a config file where modules are declared; nothing on the site indicates a hosted or browser-based version.

How the module list is organized

The documentation groups modules by purpose rather than by vendor. The main clusters:

The list is long, but the pattern is consistent: each entry is a self-contained module with its own configuration block. You don't get a fixed set of panes — you choose which modules to declare.

What this means in practice

A typical setup mixes one or two work sources with a few ambient widgets. For example, a developer might run GitHub for pull requests, Jenkins for build status, PagerDuty for who's on call, and a clock plus weather in a corner. The grid layout settings control where each module sits, so the dashboard is composed rather than pre-built.

Two things to keep in mind when reading the module list:

• Modules are opt-in. A module appearing in the docs doesn't mean it's active; it must be added to the configuration with its settings. The docs describe per-module settings, but the site excerpt doesn't spell out credential requirements for each service — expect services like GitHub, Jira, or Datadog to need their own access tokens or API keys, and check the individual module page for the exact fields.
• Some modules are read-only views, others are interactive. Feed readers, clocks, and weather are display-only; Todo, Todoist, and GitLab Todo imply you can manage items. The docs list them separately, so treat "can I act on this from the terminal?" as a per-module question.

Choosing modules for your dashboard

Use the clusters above as a checklist against your actual day:

1. Work queue — pick the one or two systems where tasks actually land for you (GitHub/GitLab issues, Jira, Trello, Asana).
2. Build and deploy health — Jenkins, TravisCI, CircleCI, or BuildKite, whichever your team uses.
3. Incidents — PagerDuty, OpsGenie, or VictorOps, plus UptimeRobot or Healthchecks for uptime.
4. Ambient context — clock, weather, stocks, crypto, or a feed reader for the corners of the grid.

If a service you rely on isn't in the list, the docs include a "Creating New Modules" section under Development, which is the documented path for extending the dashboard rather than waiting for built-in support.

The short version: WTF's value is the breadth of its module catalog combined with terminal-native display — you assemble the dashboard from documented modules, each configured individually, and the site's module index is the authoritative place to confirm a specific integration exists before you plan around it.

WTF is a personal information dashboard that runs in your terminal. To get started, follow the official docs in this order: Getting Started → Quick Start → Installation → Configuration. Installation depends on your platform and package method, and you'll need a configuration file before modules appear on screen. The site's own navigation treats Getting Started as the entry point, so start there rather than jumping straight to module pages.

What WTF is and what you need first

WTF (wtfutil.com) is described on the site as "the personal information dashboard for your terminal." It aggregates data from many sources—services like GitHub, Jira, Kubernetes, weather, stocks, and more—into a single terminal view.

Before installing, confirm:

• You have a working terminal on your platform (the docs separate installation by platform and package method, so check which applies to you).
• You know where your configuration file will live. The docs have a dedicated Configuration Files page plus Global Settings and Common Settings pages.
• You've looked at the Glossary if terms like "grid layout" or "module" are unfamiliar.

Step-by-step: install and first run

1. Open the Getting Started page. This is the recommended entry point in the site navigation and orients you before any commands.
2. Read Quick Start. It gives the shortest path to a running dashboard.
3. Follow Installation for your platform and package method. The docs list installation as its own section because the steps differ by platform; use the variant that matches your setup rather than mixing instructions.
4. Create or review your configuration file. The Configuration section covers configuration files, global settings, common settings, and grid layout. Modules only appear once they're configured, so expect an empty or minimal dashboard until this is done.
5. Launch WTF in your terminal. After configuration, the dashboard renders according to your grid layout.
6. Add modules incrementally. The Modules section lists each supported integration (Airbrake, Asana, Azure DevOps, GitHub, Jira, Kubernetes, Weather, and many others). Add one or two first, confirm they render, then expand.

Expected result: a terminal dashboard showing the modules you configured, arranged per your grid layout.

Verify it worked

• The dashboard starts without configuration errors.
• Each configured module displays data rather than an error state.
• Layout matches what you defined in the grid layout settings.

If a module shows nothing, recheck that module's entry in your configuration file and its required settings on the module's docs page.

Common sticking points

• Blank dashboard on first run: almost always a missing or incomplete configuration file. Revisit Configuration Files and Global Settings.
• Wrong install instructions: installation varies by platform and package method; confirm you're on the right variant.
• Module not appearing: check the specific module page under Modules—each has its own settings.
• Layout looks wrong: review the Grid Layout page under Configuration.

Removing WTF

The docs include an Uninstallation page alongside Installation. Use it if you want to remove WTF cleanly rather than deleting files manually.

Where to go next

• Modules — browse the full list and pick integrations relevant to your work.
• Development → Creating New Modules — if you want to build your own.
• Sponsoring and Support — the site's support entry point if you hit issues the docs don't cover.

Start with Getting Started and Quick Start, install for your platform, configure before launching, then add modules one at a time.

WTF is configured through configuration files, not through an in-app settings screen. You define shared behavior under Global Settings and Common Settings, place modules on screen with the Grid Layout, and then give each module its own configuration block. To change what your dashboard shows or where it sits, edit the config file and restart WTF.

Where configuration lives

WTF reads its settings from configuration files. The site's documentation separates configuration into four areas:

• Configuration Files — the files WTF loads on startup
• Global Settings — settings that apply across the whole dashboard
• Common Settings — shared options reused by modules
• Grid Layout — the definition of where modules appear on screen

The practical consequence: every layout or module change is a file edit. There is no menu path to memorize, and the same file controls both what appears and where it appears.

Step 1: Open your configuration file

Start from the config file WTF already uses. If you have not created one yet, the Getting Started and Quick Start pages cover initial setup and installation, and the Configuration Files page explains which files are read. Keep a copy of the working file before editing so you can restore a known-good dashboard if a change breaks startup.

Step 2: Set shared behavior first

Global Settings and Common Settings control behavior that applies beyond a single module. Configure these before adding modules, because module entries inherit shared options rather than repeating them. If a module behaves unexpectedly, check whether a common setting is overriding what you expected at the module level.

Step 3: Define the Grid Layout

The Grid Layout is where you decide placement. Treat it as a map of your terminal screen: each position in the grid is assigned a module, and the module's configuration block supplies its content and options. Two rules keep this manageable:

1. Add one module at a time and confirm it renders in the intended position.
2. Keep the module name in the layout identical to the name used in that module's configuration block.

If a module is configured but never appears, the layout is the first place to look; if it appears in the wrong spot, the layout is the only place to look.

Step 4: Configure each module you enable

Every module has its own configuration options. The documentation lists modules by category, which helps you find the right page quickly:

Open the page for each module you plan to use and apply its options in that module's configuration block. Modules that need an external account or service will have their own required settings; the module page is the authority for those, not the global section.

Verify the result

Restart WTF after editing and check three things in order: the dashboard starts without errors, each enabled module appears in its assigned grid position, and each module shows live data rather than an empty or error state. If startup fails, revert to your saved copy and reapply changes one at a time.

Common sticking points

• Editing the wrong file. Confirm you are editing a file listed under Configuration Files; changes elsewhere have no effect.
• Layout and module names out of sync. A mismatch between the grid entry and the module block is the usual cause of a missing module.
• Expecting a settings UI. Configuration is file-based, so changes require a restart to take effect.
• Adding many modules at once. Batch edits make it hard to tell which change caused a failure; add incrementally.

For anything beyond layout and shared settings — writing your own module, for example — the documentation's Development section covers creating new modules.

WTF is a personal information dashboard that runs inside your terminal. It pulls data from many services and tools into a single screen, so you can check updates without switching between browser tabs or apps. It is aimed at people who spend most of their day in a terminal and want a quick, keyboard-friendly overview of the information they care about.

How WTF Works

WTF is organized around modules. Each module connects to a specific service or data source and displays its information as a widget on the dashboard. You choose which modules to enable, arrange them in a grid, and configure each one with the settings it needs.

The site describes the product as "the personal information dashboard for your terminal" and documents three core areas:

• Configuration — configuration files, global settings, common settings, and grid layout
• Modules — the individual widgets that supply data
• Development — guidance for creating new modules

In practice, this means the dashboard is only as useful as the modules you turn on. A minimal setup might show a clock and a to-do list; a fuller setup might combine work tools, monitoring, and personal feeds.

What You Can Put on the Dashboard

The module list on wtfutil.com is broad and spans several categories. Examples include:

Because the list is long, the practical approach is to start with two or three modules you check daily and add more only when you notice yourself leaving the terminal to look something up.

Who It Is For

WTF fits people who already work in a terminal and want ambient awareness of a handful of services. Typical uses:

• A developer watching build status, open pull requests, and on-call alerts in one place
• An operations person keeping an eye on uptime checks and incident tools
• Anyone who wants headlines, weather, a clock, and a task list without opening a browser

It is less suited to someone who needs rich visualizations, sharing dashboards with a team, or interacting with services through a graphical interface. The output is text-based and lives on your own machine.

How to Get Started

The site's navigation points to a Getting Started section with Quick Start, Installation, and Uninstallation pages, plus a Glossary. The general path is:

1. Install WTF using the instructions on the Installation page.
2. Create or edit the configuration file.
3. Enable the modules you want and set their required options.
4. Arrange modules using the grid layout settings.
5. Run the dashboard and adjust the layout as you learn what you actually check.

The Configuration Files and Global Settings pages cover where settings live and which options apply across the whole dashboard, while Common Settings covers options shared by modules. Check those pages for the exact file locations and option names for your platform rather than assuming defaults.

Things to Know Before You Commit

• Configuration is manual. You will be editing config files, not clicking through a settings screen. Expect some trial and error when adding a module for the first time.
• Each module has its own requirements. Many connect to external services and will need credentials or tokens; the module's documentation page is the place to confirm what it needs.
• The grid layout is the main design decision. A crowded grid makes the dashboard hard to scan, so keep the number of visible modules modest.
• Support and sponsorship are separate pages. The site lists Sponsoring and Support and Sponsoring WTF sections if you want to know how the project is funded or where to ask questions.

If you want a single terminal screen that aggregates the services you already use, WTF is built for exactly that. Start with the Quick Start and Installation pages, enable a small set of modules, and expand from there.

Yes. WTF (wtfutil.com) is an open-source terminal dashboard whose functionality is built from modules, and its documentation includes a Development section with a page on Creating New Modules. That page is the intended starting point if you want to build a module that isn't already covered by the built-in list.

What "module" means in WTF

A WTF dashboard is a grid of widgets, and each widget is a module. Every data source you see in the docs — GitHub, Jira, Kubernetes, Weather, Stocks, Todoist, and so on — is a module that fetches or renders something and drops it into a grid position. So creating your own module is the way to surface data that no existing module covers, using the same configuration and layout system as the built-in ones.

What the docs give you

The site's navigation shows a Development section containing Creating New Modules, alongside a blog. That's the reference material for module authors. The docs also list the full set of existing modules, which is useful in two ways:

• Check before you build. With modules spanning services (Asana, Datadog, PagerDuty, Zendesk), infrastructure (Docker, Kubernetes, Azure Logs), finance (Bittrex, Finnhub, Yahoo Finance), and general utilities (Clocks, CmdRunner, Textfile, Todo), there's a reasonable chance something close already exists.
• Use them as patterns. Existing modules are the closest thing to worked examples of how a module is structured and configured.

Practical path

1. Confirm the gap. Scan the module list for anything that already pulls the data you want. If a near-match exists, adapting your config is cheaper than writing code.
2. Read Creating New Modules. Follow the Development section's page rather than guessing at structure; it defines what a module must provide.
3. Work from the source. The project is open source and hosted on GitHub (wtfutil/wtf), so you can read real module implementations directly.
4. Wire it into your config. Once built, a custom module is placed and configured like any other, using the same configuration files, global settings, and grid layout described in the Configuration section.
5. Get help if you stall. The site has Sponsoring and Support pages describing how to reach the project.

Things to keep in mind

• The docs are the authority on specifics. This overview can tell you the capability exists and where to look, but the exact interface a module must implement lives on the Creating New Modules page — don't infer it from the module names alone.
• Configuration is shared, not per-module invention. Layout, global settings, and common settings are handled at the dashboard level, so a new module slots into existing conventions rather than defining its own.
• Start with a read-only module. Modules like CmdRunner and Textfile show that simple local sources are a legitimate scope; a small module that displays one thing is a fine first project before tackling an authenticated API.

If your goal is simply to see more data in your terminal, check the existing module list first — the answer may already be there. If it genuinely isn't, the Development docs and the GitHub source give you everything needed to add it.