<p align="center">
  <img src="crates/anabolic/assets/logo/lockup.svg" alt="Anabolic" width="420">
</p>

<h3 align="center">Task Manager on steroids</h3>

<p align="center">
  An open-source performance monitoring and diagnostics tool for Windows and Linux, built in Rust.<br>
  It stays responsive when the machine does not, and answers <em>who is doing this, and why</em>,<br>
  not only <em>how much</em>.
</p>

<p align="center">
  <a href="https://github.com/RaptorTwentyOne/Anabolic/actions/workflows/ci.yml"><img src="https://github.com/RaptorTwentyOne/Anabolic/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
  <a href="https://github.com/RaptorTwentyOne/Anabolic/releases"><img src="https://img.shields.io/github/v/release/RaptorTwentyOne/Anabolic?include_prereleases&sort=semver" alt="Release"></a>
  <img src="https://img.shields.io/badge/platform-Windows%2010%20%7C%2011%20%C2%B7%20Linux-0078D4" alt="Windows 10 | 11 · Linux">
  <img src="https://img.shields.io/badge/rust-1.95%2B-orange" alt="Rust 1.95+">
  <a href="#license"><img src="https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-blue" alt="MIT OR Apache-2.0"></a>
  <a href="https://m8ven.ai/mcp/raptortwentyone-anabolic-r9uj5q?s=readme"><img src="https://m8ven.ai/badge/mcp/raptortwentyone-anabolic-r9uj5q?v=5b44c58ad85b1459b45efefc1a635f33" alt="M8ven Score"></a>
  <a href="https://glama.ai/mcp/servers/RaptorTwentyOne/Anabolic"><img src="https://glama.ai/mcp/servers/RaptorTwentyOne/Anabolic/badges/score.svg" alt="Anabolic MCP server – quality and maintenance score on Glama"></a>
  <a href="https://hub.xerj.org/contributors/cbagriacik"><img src="https://hub.xerj.org/contributors/cbagriacik/badge.svg" alt="XERJ Corpus Hub contributor"></a>
</p>

---

You open a task manager when something is wrong: a game stutters, the fans
spin up, a disk sits at 100 % and nothing says why. That is exactly when most
of them freeze, and when they do answer, they say *how much*, not *who* or
*why*. Anabolic is built for that moment:

- **It stays alive under load.** It raises its own priority, opts out of
  efficiency throttling, keeps its memory resident, never blocks its
  interface thread and reads the system once per refresh: about 1 ms of CPU
  per frame while scrolling. A running instance comes to the front in under
  100 ms.
- **It says who and why.** Who ran on each CPU core; which process reads and
  writes which file on each disk; traffic and GPU per program; which program
  started a process and how; what a hung thread waits for; which handles keep
  a dead process from going away.
- **It watches without touching.** Its regular views read system-wide tables
  and kernel traces: no process is opened, read or injected into, so a game
  is left alone while it is watched. Anything that does open a process asks
  first and says why.
- **It is honest about what it measures.** A value it cannot read is shown as
  unavailable, with the reason, never as zero.

![The Processes page: a Rust build in a terminal, with the compiler processes leading in CPU, memory and disk, next to VS Code, Chrome and Steam](docs/screenshots/processes.png)

## Contents

- [What it does](#what-it-does)
- [On Linux](#on-linux)
- [Getting started](#getting-started)
- [Keyboard](#keyboard)
- [Terminal commands](#terminal-commands)
- [AI assistants (MCP)](#ai-assistants-mcp)
- [Games and anti-cheat](#games-and-anti-cheat)
- [Privacy](#privacy)
- [Building from source](#building-from-source)
- [Contributing](#contributing)
- [Reusing the code](#reusing-the-code)
- [License](#license)

## What it does

| Page | |
|---|---|
| **Overview** | The machine at a glance: a tile for CPU, memory, disk, network and GPU, each with the app behind most of it; what needs attention (memory running out, a full or overworked disk, a hung or stuck program, one that keeps growing, a hot sensor, a program in many copies) with a button for what can be done; the busiest apps; development servers listening; what started in the last ten minutes; and this PC in a few lines. |
| **Processes** | A tree, a flat list or grouped by app, with CPU, memory, disk, network, GPU, handles, user, command line and status (efficiency mode, suspended, not responding, limited). Quick filters narrow it to what uses CPU, memory, disk, network or a GPU, what started in the last ten minutes, or the services. End, end tree, suspend, priority, cores, efficiency mode, and a notification when a process exits, with its exit code. Run new task starts a program with administrator rights or without, as Task Manager does. Details show threads with their call stacks, modules with their signatures and hashes, handles in words, network connections, the services a process hosts and the chain of processes that started it, including parents that already exited. |
| **Performance** | CPU with who ran on each core, memory and its modules, each physical disk with its partitions and the processes and files it serves, network adapters, GPUs, process I/O, temperatures and fans, and every monitor on a map of the desktop. Windows lets only drivers read the processor's own temperature sensors, so there Anabolic shows the processor's power from its energy meter, the firmware's thermal zones where it has any, the GPU's temperature, fan and (NVIDIA) power, and the disks' temperatures. |
| **History** | Every 10 seconds, the machine's totals and the processes that led, kept for 7 days by default: a day strip, an hour graph and a range picker answer "what happened at 14:32". |
| **Rules** | Per program, in the manner of Process Lasso: priority, cores, efficiency mode and CPU and memory limits applied to every new process, plus memory, CPU and handle alerts. Priority, efficiency mode and the CPU limit can wait until the program is busy or in the background, and go back when that passes. A watch that fires (memory, CPU, handles, a window not responding) can also write a dump of the process or end it. A rule can mark a program as a game. |
| **Services** | Every service with its state, startup type, account and the process it runs in, with that process' CPU and memory; start, stop (asking about dependents), restart, pause, startup type. New service, and Properties with everything the Services console sets: program, account and password, dependencies, what it does when it fails. Delete, except Windows' own services, which can be set to Disabled instead. |
| **Startup** | Run keys, Startup folders and sign-in or boot tasks with their publisher and what they cost right now; turned on and off the way Task Manager does it. Nothing is deleted. |
| **Stutters** | Frame rate, 1 % lows and frame times of every program that draws, each stutter with what else happened at that moment, and DPC/ISR time per driver, in the manner of LatencyMon. No game is opened to measure it. |
| **Network** | Traffic per program, every connection with its state and the other end's name, the ports open to others and who can reach them, and every DNS lookup with the program that made it. Development ports lists the dev servers, databases and debuggers listening, named by their tool (Vite, PostgreSQL, the Node.js debugger and more), with the ports you watch, free or with who holds each; a port is freed by ending what holds it. Close a TCP connection, or block a program in Windows Firewall and allow it again. |
| **Activity** | Process Monitor style: every file, registry key, connection and program a process touches, in order, from a kernel trace. Start a program under recording, record a running one or its whole tree, or record the whole computer and filter afterwards. CSV export. |
| **MCP** | A Model Context Protocol server for Claude and other AI assistants, off until you turn it on. See [below](#ai-assistants-mcp). |

![The Performance page's CPU view: ten minutes of total and kernel time with two earlier builds and the one running now, the busiest processes, and one graph per logical processor naming the process that ran on it](docs/screenshots/performance.png)

<sub>The screenshots show a made-up PC, not anyone's real one.</sub>

And across the pages:

- **Not responding and stuck processes**: hung windows are marked; wait
  chains show what each thread waits for, deadlocks first; a process that
  cannot finish ending says what holds it (handles still open to it, a
  driver that strips the right to end it, Windows' protection).
- **Leaks**: handle, memory and thread growth that keeps going is flagged.
- **A program in many copies**: when one program runs 50 times over from the
  same starter (a script or a build gone wrong), a bar names the starter and
  ends them all at a click. Browsers and Windows' service hosts, many
  processes by design, are left out; the number is in Settings.
- **Memory dumps**, small or full, taken from a snapshot so the process
  pauses only for a moment.
- **CPU and memory limits** (Windows): a process, or a rule's program, held
  to a share of the processor and an amount of memory with what it starts,
  by a job object: a cap Windows keeps whatever the priority, not a hint.
  They last while Anabolic runs. Windows' core processes and anti-cheat
  software are left alone.
- **Game mode** (optional): while a game is in front, busy background
  programs run at below normal priority until it ends; asked to, without a
  game too, sparing the program in front. The game, Windows' core
  processes, audio and anti-cheat software are never touched.
- **Notification area** (optional): closing the window leaves Anabolic
  running, recording the history and applying rules; alerts become
  notifications, and the icon shows how busy the CPU is.
- **Several monitors**: called up during a full-screen game, the window opens
  on another monitor (Windows: on Linux the compositor places windows).
- **Columns where you want them**: in every table, dragging a title moves
  its column, and the order and widths stay for next time. A table wider
  than the window scrolls sideways.

## On Linux

The same pages, read from Linux's own accounting: `/proc` and `/sys`, the
kernel's perf events and netlink interfaces, fanotify, and systemd and the
desktop over D-Bus. No kernel module, no eBPF program. Where Linux works
differently, the pages say how:

| Page | On Linux |
|---|---|
| **Processes** | The kernel's threads (kworkers, kswapd, the interrupt threads) are counted under one *Kernel* row, PID 2, as Windows counts its own under System; its details list them one by one. Handles are open files. A program's package stands where Windows shows its company, and its file is checked against the package's record. Dumps are core files that gdb reads. |
| **Performance** | Who ran on each core, interrupt load and the processes behind each disk come from perf events. Intel and AMD GPUs through the kernel's DRM accounting; NVIDIA through NVML, asked only while the GPU is awake, so a laptop's sleeping one stays asleep. Every temperature, fan and power sensor the kernel's hardware monitors know, per core included; a sensor on a sleeping device is left out rather than woken. Partitions, with what LUKS and LVM hold, from udev. Monitors from EDID and the desktop's own layout (KDE, GNOME). |
| **Services** | systemd's: the system's and your user's. Start, stop, restart, and enabled, disabled or masked; there is no pausing. A new unit goes to /etc/systemd/system (or your own folder); a package's unit is changed through a drop-in, as `systemctl edit` does; only units made by hand are deleted. pkexec asks for the password. |
| **Startup** | Autostart entries and systemd user units, turned off the way the desktop does it: a system-wide entry is hidden by a copy in your own folder. Nothing is deleted. |
| **Stutters** | Interrupt and softirq time per handler, in the manner of LatencyMon. Linux reports no frame times to anyone outside a game, so frame times and 1 % lows are Windows only. |
| **Network** | TCP traffic per program and per connection; Linux counts no UDP traffic per program. Its firewalls filter by address, port and user, not by program, so blocking a program is Windows only, as is the list of DNS lookups. |
| **Activity** | Every file, program and connection a process touches. There is no registry; instead, a program, a process or the whole machine can be recorded with its system calls, as strace shows them, with a count, the failures and the time spent per call. They come from the kernel's tracepoints: the process is never stopped or read. |

Around them: the notification area icon is a StatusNotifierItem (KDE has
it; GNOME needs the AppIndicator extension), the hotkey goes through the
desktop's GlobalShortcuts portal, and game mode finds the window in front on
KDE and on X11. The keyrings (KWallet, GNOME Keyring, ssh-agent, gpg-agent)
take lsass' place as what is not dumped unless allowed. Run new task runs a
command line as you, the way a terminal would; a program that needs root
asks for it itself.

## Getting started

Everything is on the
[releases](https://github.com/RaptorTwentyOne/Anabolic/releases) page: for
Windows an installer and a zip, for Linux a zip. A zip holds a single
executable with nothing to install: unpack it anywhere. Each file has its
SHA-256 checksum beside it, as a `.sha256` file (`sha256sum -c` reads it;
on Windows, compare it with `Get-FileHash`). Releases after 0.5.0 also
carry a build attestation, a signed record that this repository's release
workflow built the file: `gh attestation verify <file> -R
RaptorTwentyOne/Anabolic` checks it.

### Windows

Windows 10 or 11, x64. The installer (`anabolic-…-windows-x64.msi`) puts
Anabolic in Program Files and the Start menu, for every user of the PC;
Settings → Apps removes it again, and leaves its settings and history (see
[Privacy](#privacy)). From the zip, run `anabolic.exe` wherever you put it.
Beside it comes `anabolic-cli.exe`, the [terminal commands](#terminal-commands);
the installer puts its folder on PATH.

On an administrator account Windows asks for elevation as it starts, and with
it Anabolic sees everything: kernel traces, every process' details, disk
counters. On a standard account it runs without, shows what it can and says
what is missing and why; Settings has **Restart as admin**.

> [!NOTE]
> Releases are not code-signed yet, so Windows SmartScreen may warn when the
> installer or the program first runs. Choose **More info** → **Run anyway**,
> or build it yourself.

### Linux

x64, a C library from 2022 or later (glibc 2.35: any current distribution),
and a Wayland or X11 desktop with OpenGL.

```
./anabolic --install   # once, optional: the application menu and the taskbar icon
./anabolic
```

Anabolic runs as you. Without more it sees your own processes in full and
others' in part. **Grant full access** (top right, or in Settings) gives the
executable the capabilities it needs, once: pkexec asks for your password and
runs `setcap` on it. The window stays yours, on your desktop session; only
those rights come with it. As anyone who can run the file has them too, it
is made yours alone (mode 700) first. Kernel traces, other users' processes'
files and threads, ending them, and closing connections need it.

### Updates

Anabolic keeps itself up to date. Soon after it starts, and then once a day,
it asks GitHub whether a newer release is out. A new release is downloaded,
checked against the SHA-256 checksum GitHub lists for it, and put in place of
the old executable; it runs from the next start, or at once from the bar that
says it is installed. An install that fails (a download that broke off, a
virus scanner holding the file) is tried again after a minute, five and
thirty. In Settings → Updates it can ask first instead, or not
check at all. Copies built from source are left to their source. The first
time a new version starts, a small window says what changed since the one
before, from [CHANGELOG.md](CHANGELOG.md), which Anabolic carries inside it.

An installed copy updates through the new release's installer, without a
window, so that Settings → Apps keeps showing the right version. Changing
what is in Program Files takes an administrator, which Anabolic is whenever
it runs on an administrator's account; on a standard account the bar says
so, and the new installer can be run from the release page. On Linux the
download goes through curl, and the new file has to be granted full access
again: the rights belong to the file they were given to.

### Starting when you sign in

Settings → Window → **Start when I sign in** starts Anabolic in the
notification area as you sign in, recording the history and applying your
rules from the start. On an administrator's account it is a task in Task
Scheduler (folder `Anabolic`) that starts it elevated without asking, which
the installed copy offers: a program started elevated without asking has to
be where only administrators can change it, and a zip's copy in Downloads is
not. On a standard account it is the Run key; on Linux, an entry in
`~/.config/autostart`. Removing Anabolic with Settings → Apps removes every
user's task with it.

### Bringing it up from anywhere

**Ctrl+Alt+Esc** brings Anabolic to the front from any program while it runs;
Settings offers other keys, or none. With *Keep running in the notification
area when closed* on, closing the window leaves Anabolic running, so the key
works all day. Windows' Task Manager and Ctrl+Shift+Esc are left as they are.

On Linux the desktop asks once whether Anabolic may have the key. KDE gives
Ctrl+Alt+Esc to *Kill a window*: choose another key in Settings, or free that
one in KDE's shortcut settings.

### Command line

| Option | |
|---|---|
| `--tray` | Start in the notification area, without a window. |
| `--new` | Start another instance instead of bringing the running one to the front. |
| `--install`, `--uninstall` | Linux: add Anabolic to the application menu (a .desktop file and the icon in `~/.local/share`), or take it away. |

## Keyboard

| Keys | |
|---|---|
| Alt+Home | Overview |
| Ctrl+1 … Ctrl+9, Ctrl+0 | The pages below it, in the order of the rail; Ctrl+0 is MCP |
| Ctrl+, | Settings |
| Ctrl+N | Run new task |
| Alt+←, Alt+→ | Back and forward through the pages and processes visited; the mouse's back and forward buttons too |
| Ctrl+F | Filter processes |
| Ctrl+T | Tree, list or apps |
| Ctrl+H | Find handle: who has this file or object open |
| Space | Pause updates |
| F5 | Refresh now |
| Del, Shift+Del | End the selected process, or its whole tree |
| Shift+F10 | The selected process' menu |
| F1 | Every shortcut and what the colours mean |

## Terminal commands

What the window shows, in a terminal: for a quick look, or for a script.
On Windows they come with `anabolic-cli.exe`, beside `anabolic.exe`; on
Linux they are `anabolic`'s own (`anabolic ps`).

```
anabolic-cli ps chrome --sort memory    # processes, the busiest first
anabolic-cli kill 1234 --tree           # end a process and what it started
anabolic-cli service restart Spooler    # start, stop or restart a service
anabolic-cli ports                      # who listens, and who can reach it
anabolic-cli ps --json                  # the same as JSON, for scripts
```

| Command | |
|---|---|
| `overview` | The machine at a glance |
| `ps [FILTER]` | Processes, the busiest first (`--sort`, `--limit`, `--all`) |
| `tree [PID]`, `show PID`, `why PID` | Who started what; one process in full; why it will not end |
| `services [FILTER]`, `service NAME` | Services, and one in full |
| `ports`, `connections`, `startup` | Listening ports, connections, startup programs |
| `kill PID`, `suspend PID`, `resume PID`, `priority PID LEVEL` | Act on a process |
| `service start\|stop\|restart\|pause\|continue NAME`, `service startup NAME TYPE` | Act on a service |
| `mcp` | The MCP server without the window ([below](#without-the-window)) |
| `tools`, `call TOOL NAME=VALUE...` | Every MCP tool, and any of them called directly |

Each command answers through the MCP server's own tool, and refuses what
the tool refuses: Windows' critical processes and Anabolic itself are never
acted on, and a game or an anti-cheat program only with `--force`, after it
said what can happen. Commands run with the terminal's rights: from one that
is not elevated, other users' processes show less and acting on them is
refused. `--json` prints the tool's answer as it is; the exit code is 0 when
done, 1 when refused or failed, 2 when the command was not understood.
`anabolic-cli help` lists everything.

## AI assistants (MCP)

The MCP page (Ctrl+0) turns on a Model Context Protocol server, so Claude and
other MCP clients can read what Anabolic sees and do what you allow. It speaks
Streamable HTTP at `http://127.0.0.1:47123/mcp` (the port can be changed),
listens on this computer only, and every request needs the access key the
page shows. The page gives the command for Claude Code and the JSON for other
clients, and lists the clients that connected and every call they made.

What clients may do is chosen on the page, kind by kind; a call of a kind
that is off is refused and says where to turn it on:

| Kind | Tools |
|---|---|
| Read what the PC is doing (on by default) | overview, CPU, memory, disks and their partitions, GPUs, temperatures and fans, monitors, hardware, stutters, history, processes and their tree, one process in full (who started it, what it hosts, its connections), why a process will not end, leaks, connections, open ports, network usage, DNS lookups, services, startup programs |
| Turn kernel traces on for a while | who runs on each core, which files each disk serves, traffic per connection, frame times |
| Look inside a process | handles, modules, thread stacks, wait chains |
| Write memory dumps | small or full dumps (never of lsass, or on Linux of the keyrings) |
| Record what processes do | Process Monitor style recordings, of a process, a name or the whole machine; on Linux, a process' system calls too |
| End processes | end a process or a tree |
| Suspend, resume, reprioritise and limit | suspend, resume, priority, cores, efficiency mode, CPU and memory limits |
| Control services | start, stop, restart, pause, startup type |
| Close connections, block programs | close a TCP connection; Windows Firewall block and unblock (Windows) |
| Turn startup programs on and off | the way Task Manager does |

Tools that open a process (inspection and dumps), and actions on a game or an
anti-cheat program, refuse the first call with the risks in words: the
assistant has to tell you and call again with `force=true` only if you agree.
The system's critical processes (Windows' own; on Linux init, the kernel and the
session's compositor) and Anabolic itself are never acted on.

The server also offers resources (`anabolic://overview`,
`anabolic://process/{pid}` and others) and prompts for common questions
("why is the PC slow", "why does my game stutter", "what happened at 14:32").

### Without the window

A client can also start Anabolic itself, out of sight, for as long as it
needs it, and speak to it over standard input and output: no port and no
key, and the window need not run.

```json
{
  "mcpServers": {
    "anabolic": {
      "command": "C:\\Program Files\\Anabolic\\anabolic-cli.exe",
      "args": ["mcp"]
    }
  }
}
```

On Linux the command is the `anabolic` file itself; for Claude Code,
`claude mcp add anabolic -- anabolic-cli mcp`. The MCP page shows both for
the copy it runs from. Such a server may do what the MCP page allows
(`--allow read,end,...` or `--allow all` instead), except setting CPU and
memory limits, which last only while Anabolic runs. It runs with the
client's rights. `anabolic-cli mcp --http` serves Streamable HTTP like the
page's server instead, until Ctrl+C. The [Dockerfile](Dockerfile) builds the
same server into an image, for MCP directories that try servers in a
container (where it sees the container, not the machine).

## Games and anti-cheat

Anabolic watches from system-wide tables and kernel traces: its regular views
do not open game processes, read their memory or inject anything. What does
open a process (memory dumps, a thread's call stack, duplicating handles,
reading modules) asks first. Game mode never touches the game, Windows' core
processes or anti-cheat software.

The process that holds Windows' sign-in secrets (lsass) is not dumped unless
*Allow dumps of lsass.exe* is turned on in Settings: its memory is what
credential-stealing tools take, so antivirus software stops any program that
reads it and may quarantine Anabolic. MCP clients can never dump it.

On Linux the keyrings (KWallet, GNOME Keyring, ssh-agent, gpg-agent) hold the
session's passwords and keys unlocked, and are not dumped unless *Allow dumps
of the keyrings* is on.

How an anti-cheat reacts to any program is up to its vendor; Anabolic makes
no promise on their behalf.

## Privacy

Anabolic has no telemetry. The one request it makes by itself is the update
check: GitHub's API is asked for the latest release, and the request carries
nothing about this PC beyond what any download does (its address, and
`Anabolic/<version>` as the program asking). Settings → Updates turns it off.

Looking a file up on VirusTotal or an address on ipinfo.io opens your
browser, and only when you ask. Remote addresses get their names from the
system's DNS resolver.

Everything it keeps stays on this computer:

- `%APPDATA%\Anabolic` on Windows: settings.
- `%LOCALAPPDATA%\Anabolic` on Windows, `~/.local/share/anabolic` on Linux
  (settings there too): the history (process names and command lines, which
  can include whatever a program was started with), memory dumps and exports
  you ask for, and `stalls.log`, the moments Anabolic's own window fell
  behind. Turn the history off or shorten it in Settings.

What the MCP server's tools return goes to the program that called them,
and on to the service it uses. The full policy is in
[PRIVACY.md](PRIVACY.md).

## Building from source

Rust 1.95 or newer; on Windows with the MSVC toolchain. On Linux no
development packages are needed: Wayland, X11, OpenGL and the rest are
loaded as the program starts.

```
cargo build --release
```

The result is `target\release\anabolic.exe` (with `anabolic-cli.exe`, the
terminal commands) or `target/release/anabolic`, a single executable with
its fonts and icons embedded. `cargo test` runs the
tests; the few that need administrator rights (on Linux, full access) skip
themselves without them.

The workspace has two crates: `crates/anabolic-core` reads and controls the
system (process scans, kernel traces, handles, services, the history) and has
no interface; `crates/anabolic` is the egui application and the MCP server.
Each core module says what it means on every system; what reads it lives
beside it, in `windows/` and `linux/`.

`installer/` holds the Windows installer: `dotnet build installer
-p:ProductVersion=x.y.z -p:BinDir=<folder with anabolic.exe and
THIRD-PARTY-NOTICES.html>` makes `anabolic.msi` with WiX.

## Contributing

Bug reports, ideas and pull requests are welcome;
[CONTRIBUTING.md](CONTRIBUTING.md) says where each goes and what the code
holds to. Questions go to
[Discussions](https://github.com/RaptorTwentyOne/Anabolic/discussions), and
security problems, privately, as [SECURITY.md](SECURITY.md) says.

## Reusing the code

Open source is not the same as free for the taking. Anabolic's code is open
so that it can be read, learned from and built on, and its license asks one
thing in return: credit.

- **Copying or adapting it**, a file or a part of one: keep the copyright
  and license notice with it, and name Anabolic among your project's
  notices. That is the whole of what the MIT license asks, and it is not
  optional.
- **Rewriting it** while working from it, by hand or by having a tool or an
  AI assistant rewrite it, is still adapting it. Renamed variables and
  reworded comments do not make it new code; the notice stays.
- **Ideas** are free. Nobody owns a feature: if Anabolic gives you one,
  write your own code for it, and a mention is welcome.

## License

Licensed under either of

- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE))
- MIT license ([LICENSE-MIT](LICENSE-MIT))

at your option.

Unless you explicitly state otherwise, any contribution intentionally
submitted for inclusion in the work by you, as defined in the Apache-2.0
license, shall be dual licensed as above, without any additional terms or
conditions.

The Aldrich font is under the SIL Open Font License
([crates/anabolic/assets/fonts/OFL.txt](crates/anabolic/assets/fonts/OFL.txt)).