# catppuccin/palette: one pastel colour set, shipped as a typed package

> The Catppuccin palette package holds the flavour definitions that the whole Catppuccin ecosystem shares, and it is published for Node through npm, for Deno through JSR and deno.land, and as CSS, Sass and a dozen language ports. The data lives in one palette.json and one TypeScript module, and the README documents exactly which fields each consumer can rely on.

**catppuccin/palette** — 🎨 Soothing pastel theme to use within your projects!

- Repository: https://github.com/catppuccin/palette
- Website: https://www.npmjs.com/package/@catppuccin/palette
- Stars: 744 · Forks: 47
- Language: TypeScript
- License: MIT
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/catppuccin-palette

## One data file, many consumers, and the ports are the point

catppuccin/palette is the repository that holds the Catppuccin colour definitions, and the description calls it a soothing pastel theme to use within your projects.

The interesting structural decision is that the palette is not a stylesheet or a design file. It is data, published as a library, with the rest of the ecosystem derived from it. The repository layout shows the raw material: a palette.json at the root, a mod.ts TypeScript module, a deno.json and deno.lock for the Deno side, an import_map.json, a mod.test.ts, a types/ directory, a scripts/ directory and a shell.nix. The docs/ directory holds the CSS and Sass guides.

The distribution list is what shows the scale of the derivation. The library is on npm for Node, through JSR and through deno.land/x for Deno, and there are separate documents for CSS and Sass for web development. Beyond that there are ports of the library for Elixir, Flutter, Gleam, Go, Java, Lua, Nim, Python, Ruby, Rust, Tailwind CSS and V.

Twelve ports is a lot of places for a colour to be wrong, and that is the argument for the central package. A hex value that changes in palette.json propagates to every port, and the ports exist so that a Catppuccin theme in a Rust terminal or a Nim application matches one in a web app.

The repository is not archived, the last push was on 2026-10-03, and the release history shows v1.8.0 on 2026-03-21 after v1.7.1 and v1.7.0 in November 2024. The licence is MIT, and the copyright line in the README reads 2021-present Catppuccin Org.

## The Node entry points are flavors, flavorEntries and version

The npm package exposes three things at the top level, and the README's example makes the difference between them clear.

```ts
import { flavors, flavorEntries, version } from "@catppuccin/palette";
import chalk from "chalk";

// a string containing the version of the library
console.log(version);

// an object containing all catppuccin flavors
console.log(flavors);

// typed helper when iterating flavors
flavorEntries.map(([_, flavor]) => {
  console.log(`${flavor.name} is a ${flavor.dark ? "dark" : "light"} theme.`);
  console.log(`It has ${flavor.colorEntries.length} colors:`);
```

version is a string, which is the small thing worth copying into your own project, because knowing which palette version produced a screenshot or a token file is the difference between reproducing it and guessing.

flavors is an object containing all the Catppuccin flavours, keyed by name. flavorEntries is the typed helper for iterating them, and it gives you the key alongside the value, which is what you want when you are generating a file that needs both the name and the colour data.

Each flavour carries a name, a dark flag telling you whether it is a dark or a light theme, and a colorEntries array. The example then walks the colours, and each entry is a name paired with an object holding a hex value, an rgb triple and an accent flag:

```ts
  flavor.colorEntries.map(([colorName, { hex, rgb, accent }]) => {
    console.log(
      chalk.bgRgb(rgb.r, rgb.b, rgb.g)(` ${hex} `),
      colorName,
      accent
    );
  });
```

The rgb object is a plain triple of r, g and b channels, so it drops straight into any library that wants numeric channels, and the accent flag marks the colours the design system treats as accents rather than as the base palette.

The example then moves to the ANSI tables, which is a separate collection on the flavour, ansiColorEntries, giving each terminal colour a normal and a bright variant with its own hex and its own code:

## The ANSI table is a separate view of the same palette

Terminal output is a special case, because a terminal palette has sixteen slots with a normal and a bright variant each, and the names are conventional rather than a design system concept. The library exposes that as ansiColorEntries, and the README's example is short:

```ts
  flavor.ansiColorEntries.map(([colorName, ansi]) => {
    console.log(
      chalk.hex(ansi.normal.hex)(`[${ansi.normal.code}] Normal ${colorName}`)
    );
    console.log(
      chalk.hex(ansi.bright.hex)(`[${ansi.bright.code}] Bright ${colorName}`)
    );
  });
});
```

Each ANSI entry has a normal and a bright side, and each side has a hex value and a numeric code. The code is the part that matters for configuration: it is the number you put in a terminal theme definition or a colour scheme file, and the hex is the part that matters for rendering.

That distinction is a practical one. A theme for an editor or a terminal is usually expressed as hex values, but a colour scheme that maps onto the sixteen standard slots needs the codes. Having both in one place means the mapping from a design token to a terminal slot does not have to be maintained by hand, which is where those mappings usually go wrong.

It is also worth noticing that the ANSI colours are a separate accessor rather than a flag on the ordinary colour entries. The design palette and the terminal palette are related but not identical, and a consumer that wants the terminal view asks for it explicitly.

## Deno gets the same data through two different channels

The Deno section is short but it answers a question you would otherwise have to guess at, namely whether the Deno build is the same library or a reimplementation.

The library is available through JSR and through deno.land/x/catppuccin, and the example imports from the deno.land URL directly:

```ts
import {
  flavors,
  flavorEntries,
  version,
} from "https://deno.land/x/catppuccin/mod.ts";
import { bgRgb24 } from "https://deno.land/std/fmt/colors.ts";
```

The three named exports are identical, so the API surface is the same, and the colour rendering uses the standard library's own formatting function rather than chalk. The Deno example also shows a slightly different call, passing the rgb object as a spread into the background colour function:

```ts
  flavor.colorEntries.map(([colorName, { hex, rgb, accent }]) => {
    console.log(bgRgb24(`  ${hex}  `, { ...rgb }), colorName, accent);
  });
```

The repository supports both channels: deno.json and deno.lock for the JSR side, an import_map.json, and a shell.nix for the Nix-flavoured consumers of the ecosystem. The mod.test.ts file at the root is the test for the Deno module.

The reason for having both is worth understanding if you are publishing to Deno. JSR is the package registry Deno is built around, with its own versioning and its own rules about how dependencies are declared, while deno.land/x is the older third-party module registry where a module is a repository path with a version tag. Supporting both means the same source is reachable from either, which matters for a package that other tools depend on.

## Graphics editors get palette files, not the library

For anyone working in a design tool rather than in code, the distribution is different and the README is explicit about it: use the respective files in the latest GitHub release.

The table maps programs to directories. The Adobe Suite, Affinity Suite and Sip are in ase/. Aseprite, Gimp, Inkscape and Krita are in gimp/. Procreate is in procreate/. And the Apple Color List format, the .clr file, is in clr/.

Four directories rather than one is a reasonable structure, since the file formats are not related to each other. A GIMP palette, an Aseprite palette, a Procreate document and an Apple colour list are four different formats that happen to contain the same colours, and generating each from the same source is the only way to keep them in step.

The choice to ship these in the release rather than in the repository is also sensible. They are generated artefacts, and the scripts/ directory in the repository is what produces them. Shipping them from the release means the files you download are the ones the release workflow built, with the version of the palette that the release names.

For web development there is a third path, the CSS and Sass documents in the docs/ directory, which cover the custom properties and the mixins and variables for the two preprocessor workflows. The Sass document in particular is the one to read if you want the palette to generate a whole theme rather than to hand you the values.

One thing the README does not state anywhere is the file format of palette.json itself, and the repository's public interface is effectively the TypeScript module rather than that JSON. If you are writing a port, the module and the JSON are the two things to read.

## Conclusion

catppuccin/palette is worth depending on if you are building anything that has to match the Catppuccin look, because it is the single source the rest of the ecosystem is generated from, so a colour that changes here changes everywhere rather than in one port that drifted. It is the wrong tool if you only need a handful of hex values, since a dependency and a version to track is more than a copy-paste of a few hex values. Before you adopt it, verify three things yourself: that the flavour and colour names you use are stable across the version you pin, since the package is at 1.8.0 and the naming has to be consistent for the ports to agree, that the accessor you pick is the one you want, because the typed entries, the plain object and the ANSI tables expose different levels of detail, and that the documentation you read matches the release you install, since the release history shows a long gap between 1.7.1 in November 2024 and 1.8.0 in March 2026.

## FAQ

### What is the catppuccin/palette package?

It is the library that holds the Catppuccin flavour and colour definitions, published on npm for Node, through JSR and deno.land/x for Deno, with CSS and Sass documents for web work and ports for Elixir, Flutter, Gleam, Go, Java, Lua, Nim, Python, Ruby, Rust, Tailwind CSS and V.

### How do I install the Catppuccin palette in Node?

Run npm install @catppuccin/palette, then import flavors, flavorEntries and version from the package. flavors is an object of all the flavours, flavorEntries is a typed helper for iterating them, and version is a string identifying the library version.

### What data does each Catppuccin colour entry contain?

Each entry in a flavour's colorEntries pairs a colour name with an object holding a hex value, an rgb triple of r, g and b channels, and an accent flag. The flavour itself also carries a name, a dark flag for whether it is a dark or light theme, and the ANSI colour table.

### How do I get Catppuccin colours into GIMP or Aseprite?

The README says to use the files in the latest GitHub release rather than the library. Aseprite, Gimp, Inkscape and Krita are in the gimp/ directory, the Adobe and Affinity suites in ase/, Procreate in procreate/ and Apple Color List files in clr/.

### What is the latest version of the Catppuccin palette package?

The newest release is v1.8.0 from 2026-03-21, after v1.7.1 and v1.7.0 from November 2024. The repository is not archived and the last push was on 2026-10-03, and the project is MIT licensed.

## Sources

- [catppuccin/palette on GitHub](https://github.com/catppuccin/palette)
- [License: MIT](https://github.com/catppuccin/palette/blob/main/LICENSE)
- [Project website](https://www.npmjs.com/package/@catppuccin/palette)
- [README](https://github.com/catppuccin/palette/blob/main/README.md)
- [Releases](https://github.com/catppuccin/palette/releases)

---

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