# Rink turns a unit expression into an answer, and tells you what the units mean

> Rink is an open source unit-aware calculator written in Rust, usable as a terminal application, a web interface at rinkcalc.app and a library through rink-core, covering SI, CGS, customary and historical units plus currency. It suits an engineer who wants dimensional analysis rather than a number from a formula, and it is a GPL licensed project whose data file carries its own terms.

**tiffany352/rink-rs** — Unit conversion tool and library written in rust. Repo moving to Codeberg: https://codeberg.org/tiffany/rink

- Repository: https://github.com/tiffany352/rink-rs
- Website: https://rinkcalc.app/about
- Stars: 584 · Forks: 38
- Language: Rust
- License: GPL-3.0
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/tiffany352-rink-rs

## The answer keeps its units, and that is the point

Rink is an open source unit-aware calculator that can be used for physics and engineering calculations, as well as dimensionality analysis. The project description also says the most common version is the command line interface `rink`.

What unit-aware means in practice is visible in the first example, which asks what it costs to run a computer for a year given 100 watts for four hours a day and a price per kilowatt hour.

```
> 0.1545$/kWh * 100W * (4 hours / day) to $/year
approx. 22.57196 USD / tropicalyear
```

Two things are happening. The expression multiplies quantities, and the unit of the result is derived, not typed. And the final result is a rate per year, in the currency unit, so a price per hour of electricity becomes a price per year without a conversion factor written anywhere.

The second example shows the same idea applied to a physical quantity.

```
> volume of moon * (19.283 g/cm^3) * G / (radius of moon)^2
approx. 9.365338 meter / second^2 (acceleration)
> ans to gravity
approx. 0.9549987 gravity (acceleration)
```

Rink picks the SI derived unit for the quantity it finds, so the acceleration comes back in meters per second squared with the label acceleration, and asking to express the answer in gravity gives the ratio. That is dimensional analysis as an interactive calculator rather than a check you run afterwards.

## It explains the units instead of hiding them

The feature list includes showing SI physical quantities, finding applicable SI derived units automatically, detailed error messages, and helping with dimensionality analysis by offering unit factorizations and finding units for quantities.

The third example in the documentation shows the explanatory side. You ask what a hogshead is, and Rink answers with a definition and a decomposition.

```
> hogshead
Definition: ushogshead = 2 liquidbarrel = approx. 238480942.3 millimeter^3 (volume; m^3)
> liquidbarrel
Definition: liquidbarrel = 31.5 usgallon = approx. 119240471.1 millimeter^3 (volume; m^3)
> rod
Definition: rod = 5.5 yard = 5.0292 meter (length; m)
```

So the unit database is not just a lookup table of factors. It is a graph, and Rink will walk it: a hogshead is two liquid barrels, a liquid barrel is 31.5 US gallons, and a rod is 5.5 yards. Each definition carries the dimension, volume or length, and the SI base unit it resolves to.

That is what makes the odd units usable. The fuel efficiency example converts 9.4 km/l into mpg and then into rods per hogshead, and the second conversion is a category error in normal terms that Rink allows precisely because both are the same dimension, fuel efficiency.

```
> 9.4 km/l to mpg
approx. 22.11017 mpg (fuel_efficiency)
> 9.4 km/l to rods per hogshead
approx. 445741.0 rod / ushogshead (fuel_efficiency)
```

The unit sets listed as supported are SI, CGS, natural, international customary, US customary, UK customary, and historical measurements, plus currency conversions, and temperature conversions are called out separately.

## Installing it through a package manager, or from a release

The install table lists five package managers, and the commands are the same shape you would expect from any Rust project. The table in the project documentation reads like this.

```
| Package Manager | Command              |
| --------------- | -------------------- |
| Cargo           | `cargo install rink` |
| Homebrew        | `brew install rink`  |
| Pacman          | `pacman -S rink`     |
| Nix             | `nix-env -i rink`    |
| Scoop           | `scoop install rink` |
```

Downloads are also available from the rinkcalc.app releases page.

The Cargo route is the one that matters if you want to build from source, because the repository is a Cargo workspace with five members.

```toml
[workspace]
members = ["core", "rink-js", "sandbox", "cli", "irc"]
default-members = ["cli"]
```

The default member is the cli, so a plain cargo build in the repository gives you the terminal application, and the other members are opt-in.

The Makefile shows the packaging side, which is a GNU make file with a fixed prefix of /usr/local, a RINK_PATH under the prefix's share directory, and targets for the binary, the man pages, the HTML docs and the install. The man pages are generated from AsciiDoc sources in docs/ with asciidoctor, and the build flags are worth noting: the release profile strips debuginfo, sets opt-level to z for size, and enables link time optimisation.

For a Rust library user the dependency is the core crate, and the documentation shows the manifest entry.

```toml
[dependencies]
rink-core = "0.9"
```

The docs.rs badge points at rink-core, so the library has its own published API documentation separate from the application.

## The workspace is bigger than a calculator

The directory listing is a good guide to the scope. There is core/ for the calculation engine, cli/ for the terminal application, rink-js/ for the JavaScript binding that the web interface uses, sandbox/ for the sandboxed execution of expressions, irc/ for an IRC interface, web/ for the web interface, docs/ for the documentation sources, and irc/ as well as a sandbox directory alongside them.

The sandbox deserves a note, because executing expressions a user typed is exactly the operation you do not want to do unsandboxed. There is a separate crate for it rather than an inline check.

The top level also carries ARCHITECTURE.md, which the contribution section points to for an overview of how the project is structured, and DEVELOPMENT.md for local development setup. PACKAGING.md, the Makefile, a Cargo.lock and the .travis.yml file describe the build and release process, and the .editorconfig and .tokeignore files handle formatting and token counting for the documentation.

There is also SECURITY.md, and a .codecov.yml for coverage reporting, so the project treats the library as something other people will embed.

## One licence for the code, another for the unit data

The licence section is the part of the documentation most likely to surprise an adopter, and it is a two-way split.

The Rink source code is licensed under the Mozilla Public License, version 2, with details in LICENSE-MPL. The data file definitions.units is licensed under the GNU General Public License, version 3, with details in LICENSE-GPL.

That distinction has consequences. The definitions file is the substance of the calculator: it is the unit database that makes the hogshead, the rod and the US gallon resolvable. For a program that only reads the file and computes with it, the obligations of the GPL on that data are the question to answer before you ship. For a program that modifies or redistributes the data, the analysis is harder.

The project metadata lists the licence as GPL-3.0, which is the conservative reading of the pair, and the repository root contains both LICENSE-GPL and LICENSE-MPL, so the terms are there to read rather than infer.

The contribution section is aligned with the split. Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work grants the rights lined out in the MPL, including larger works with secondary licenses.

## The project is moving hosts, and that matters for a dependency

The repository description carries a notice that is easy to skim past: Repo moving to Codeberg, with the address codeberg.org/tiffany/rink.

So the GitHub repository is in the middle of a migration, and a new dependency should be pinned to the Codeberg project rather than to the GitHub mirror. The homepage is rinkcalc.app/about, and the project has a web interface there, which the documentation describes as useful for doing calculations on mobile, in addition to the terminal-based interface.

The release history shows the project is still moving. The listed versions are Rink v0.9.0 on 2026-04-25, v0.8.0 on 2024-04-21 and v0.7.0 on 2024-01-07, and the last push was on 2026-08-31 with the repository not archived. The changelog is published on the website rather than in the repository, and the documentation for the expression language, the CLI man page and the configuration file are all hosted at rinkcalc.app.

The 0.x version number is the honest signal here. A calculator whose unit database and expression language are the product will keep changing shape, and the semver contract you get from a 0.x crate is weaker than the one a 1.0 crate gives you.

## Where Rink is the wrong tool

There is a clear case against it, and it is worth stating because the web interface can look like a general purpose calculator.

Rink is a unit-aware calculator, not a numerical workbench. It has arbitrary precision math, but it is an expression evaluator with a unit database attached, and the documentation is written around physical and engineering quantities. A statistician wanting a matrix library, a data scientist wanting a dataframe, or a financial analyst wanting a spreadsheet will not find that here. Currency conversion is a feature of the unit database rather than a financial data feed, and the project does not claim live rates.

There is also the licensing constraint, which for some organisations is decisive on its own. A permissive licence with a data file you can redistribute without strings attached is a different proposition from MPL source with GPL data.

And the alternative has to be named honestly. Doing the arithmetic yourself in Python with a units library gives you programmatic access and permissive terms, at the cost of the unit database and the interactive expression language. Rink's contribution is precisely the part you would otherwise build: a large, curated, dimensional definition of units, including the historical and customary ones, with automatic SI derived unit selection and a way to ask what a unit actually is. If your work is physics and engineering, that database is worth having. If your work is not, the calculator is the smaller half of the value.

## Conclusion

Rink fits a physicist, an engineer or a student who wants a calculation to carry its units and to be checked for dimensional consistency, and who wants to script that in Rust or paste a calculation into a browser on a phone. It does not fit a spreadsheet workflow, and it does not fit a product that needs a permissive licence, since the source is under the Mozilla Public License version 2 and the definitions data file under the GNU General Public License version 3. Before adopting it, read the manual for the expression language, check the definitions file for the units your work depends on, and note that the project is moving to Codeberg, so the GitHub repository at tiffany352/rink-rs is a mirror of the codeberg.org/tiffany/rink project.

## FAQ

### How do I install Rink?

The most common version is the command line interface rink, and the documentation lists cargo install rink for Cargo, brew install rink for Homebrew, pacman -S rink for Pacman, nix-env -i rink for Nix and scoop install rink for Scoop. Downloads are also available from the rinkcalc.app releases page.

### Can I use Rink as a Rust library?

Yes. The core crate is published as rink-core, with the manifest entry rink-core = "0.9" under dependencies, and its API documentation is published on docs.rs.

### What licence applies to Rink?

The source code is under the Mozilla Public License version 2, while the definitions.units data file is under the GNU General Public License version 3. Both licence files are in the repository.

### Where is the Rink repository hosted now?

The project description states that the repository is moving to Codeberg at codeberg.org/tiffany/rink, and the GitHub repository tiffany352/rink-rs is where the code is mirrored. The web interface is at rinkcalc.app and the documentation is hosted there too.

## Sources

- [License: GPL-3.0](https://github.com/tiffany352/rink-rs/blob/master/LICENSE)
- [Project website](https://rinkcalc.app/about)
- [README](https://github.com/tiffany352/rink-rs/blob/master/README.md)
- [Releases](https://github.com/tiffany352/rink-rs/releases)
- [tiffany352/rink-rs on GitHub](https://github.com/tiffany352/rink-rs)

---

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