# Mitos: turning images and GIFs into ASCII art for branded assets

> Mitos is an ASCII art generator from Oxide Computer Company that renders images, GIFs and custom JavaScript into text illustrations, with preprocessing controls, custom character sets, animation playback and export options. It is built on play.core, and the README is explicit that it is currently an internal tool tightly coupled to Oxide's design system.

**oxidecomputer/mitos** — ASCII art generator for brand assets

- Repository: https://github.com/oxidecomputer/mitos
- Website: https://mitos.shared.oxide.computer/
- Stars: 528 · Forks: 31
- Language: TypeScript
- License: not declared
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/oxidecomputer-mitos

## What the tool is for, in Oxide's own terms

Mitos is an ASCII art generator built by Oxide Computer Company. It converts images and GIFs into ASCII text illustrations, with a live-code option, and it is used for producting branded ASCII graphics.

That last clause narrows the scope usefully. This is not a general ASCII art toy. It exists to produce branded graphics, which in Oxide's case means the illustrations used in their product surfaces and marketing, and the live-code option exists so that an artist can tweak the rendering interactively rather than re-uploading an asset each time.

The tool is built around three sources of input. Images, GIFs, and custom JavaScript code. The third one is the interesting choice. Rather than only converting existing images, Mitos lets you describe the artwork in code, which means the output can be parameterised: the same script can render different text, different colours or different layouts.

Around that sit the controls that make the output usable. Preprocessing controls cover brightness, contrast, dithering and inversion. Customizable ASCII character sets let you choose the ramp that maps luminance to characters. There is real-time preview with zoom and pan, animation support with playback controls, multiple export options, and a grid overlay.

The animation and GIF handling are the parts that distinguish it from a simple image-to-text converter. A GIF source means a multi-frame output, which is what you need for a logo animation that plays in a terminal, and the playback controls suggest the preview is a proper animation timeline rather than a frame stepper.

A live deployment is available at mitos.shared.oxide.computer, which is the fastest way to see what the output actually looks like without installing anything.

The primary language is TypeScript, the default branch is main, there are no GitHub releases, and the last push was on 2026-09-09. The homepage of the live tool is the same address as the project's homepage field.

## The play.core dependency and why it exists

Mitos builds on play.core by Andreas Gysin, an ASCII rendering library with an API inspired by GLSL programming.

The README explains the choice, and the reasoning is worth reading closely because it is the kind of decision that usually gets made for a reason that only shows up later. Whilst it might be more efficient to process and render the text directly to the DOM, sidestepping the need for a library, the library enables consistent rendering and easier packaging of self-contained ASCII art components.

So the trade is between writing the renderer inline and getting a reusable, consistent rendering path plus a component you can package and drop elsewhere. The GLSL-inspired API is a notable detail, because it means the library's mental model is the shader model: you write something that reads like a small program producing the text, rather than a sequence of imperative drawing calls.

For a company like Oxide, which builds hardware and ships a lot of terminal and console interfaces, having one rendering path is worth an extra dependency. For an independent user, the same argument may or may not hold, and the licence terms matter here.

The Credits section attributes the work to Oxide Computer Company, based on play.core by Andreas Gysin, and lists the licence as Mozilla Public License, v. 2.0. Note that the repository metadata itself lists the licence as unknown, so the credits section is where the actual terms are stated, and the LICENSE file at the root is what governs in the end.

The tree backs up the emphasis on self-contained components. There is a .licenserc.yaml for automated licence header checking, and a .mcp.json at the root, which is a Model Context Protocol configuration. That last file is worth flagging: the tool exposes itself as an MCP server, which is how an AI coding agent would drive the generator rather than a person clicking through the UI.

## The stack and what the tests tell you

The technology list is short: React, TypeScript, Vite, TailwindCSS, CodeMirror for the code editor, and gifuct-js for GIF processing.

Each of those has an obvious job. React and TypeScript for the application, Vite for the build, Tailwind for styling, CodeMirror because the live-code option needs a real editor rather than a textarea, and gifuct-js because decoding a GIF in the browser needs a parser, and this one handles it.

The dependency list adds a few things the technology list does not mention, and they explain the features. canvas-record records the canvas for export, file-saver and jszip handle downloading, opentype.js deals with text and fonts, esbuild-wasm compiles the custom JavaScript, media-codecs handles media decoding, motion is the animation library, and sonner is the toast component.

The interactive UI is built on Radix UI primitives and Ariakit, with react-aria and react-stately for accessibility and state, and the design system comes from @oxide/design-system at version 7. That last dependency is the clearest signal of the project's coupling to its origin, and the README says so directly in the Contributing section: in its present state, Mitos is an internal tool for Oxide Computer Company and is tightly coupled to Oxide's design system.

The test setup is the strongest signal that this is a serious codebase rather than a script. There are unit tests run with the Bun test runner, a watch mode, a coverage mode, and end-to-end tests with Playwright, including a script to update snapshots. The CI script runs formatting check, type check, lint and tests in sequence.

```bash
bun run fmt:check && bun run tsc && bun run lint && bun run test
```

There is also an e2e/ directory at the root, a tests/ directory, and a playwright.config.ts. For a tool whose output is visual, Playwright snapshot testing is the right choice, since the correct output is a picture and a text assertion on it would not tell you much.

## Getting it running locally

The Getting Started section is three steps and it uses Bun throughout.

Clone the repository and enter it.

```bash
git clone https://github.com/oxidecomputer/mitos.git
cd mitos
```

Install the dependencies.

```bash
bun install
```

Start the development server.

```bash
bun run dev
```

The Bun choice is consistent throughout the project rather than incidental. The package manager script is bun install, the test runner is bun test, and the lockfile is bun.lock with a bunfig.toml alongside it.

That has a practical consequence worth knowing before you start. The tooling assumes Bun is installed, and while the underlying application is standard React and Vite and would in principle run under npm, the scripts as written call bun test and the coverage and watch variants are Bun-specific. If your environment is Node-only, the developer workflow documented here does not apply as written.

The application itself is a standard Vite setup: vite.config.ts, tsconfig.json, index.html, an app/ directory for the source, and components.json which is the shadcn-style component registry configuration that pairs with the Tailwind setup and the Radix primitives in the dependency list.

For deployment there is a vercel.json, which matches the live instance hosted at mitos.shared.oxide.computer, and a docs/ directory. The e2e/ and tests/ directories, playwright.config.ts and the mcp/ directory complete the picture of a project with a real CI story rather than a demo.

## Where Mitos is the wrong choice

There are three limits, and the first one is stated in the README's Contributing section rather than hidden.

The first is that this is an internal tool. In its present state, Mitos is an internal tool for Oxide Computer Company and is tightly coupled to Oxide's design system. While the project is open to pull requests, the authors are a small company and the primary goal of the repository is as an internal tool, so they cannot guarantee that all pull requests will be integrated.

That is an unusually candid statement and it should be read literally. If you are evaluating this for a production pipeline, the honest reading is that you are evaluating a dependency on one company's internal tooling, and your ability to influence it is limited. The @oxide/design-system dependency is not a detachable detail either, since the interface is built on it and it is versioned as a package.

The second is that the licence position needs resolving before use. The credits list Mozilla Public License, v. 2.0, while the repository metadata classifies the licence as unknown, and there is a .licenserc.yaml but the licence header configuration is not described in the README. MPL 2.0 is a file-level copyleft, which means modifications to a covered file must be published. For a company embedding the output in its own product, the licence obligations attach to the library rather than to the generated art, but the exact relationship between the play.core dependency and the generated output is worth checking, because the README does not discuss it.

The third is the scope of what it does not do. It generates ASCII art. It is not a general image editor, not a logo designer, not a font tool, and the character set is a ramp rather than a drawing surface. If your need is a terminal-rendered illustration of a brand mark, this fits. If your need is fine-grained control over typography or colour in a terminal, you are looking at the wrong category of tool and should be looking at how the character set and the escape sequences are composed rather than at Mitos.

The honest alternatives are two different kinds of thing. For producing ASCII art from an image at large volume without a browser, an image-processing script using something like ImageMagick's text output or a dedicated converter is more scriptable and has no build step at all. For the specific case Oxide is solving, which is animated branded ASCII in a product interface, the play.core library on its own is the closer dependency, and the parts of Mitos that are genuinely additional are the UI, the GIF handling and the export pipeline.

What Mitos offers over either is the whole chain in one place with an editor attached, and the live hosted instance means you can evaluate it without touching the code.

## Conclusion

Adopt Mitos if you need ASCII renderings of brand assets, such as a logo animation for a terminal UI, since it handles images, GIFs and code-driven art in one place with export support. Do not adopt it expecting a general-purpose project, because the README states it is an internal tool tightly coupled to Oxide's design system and that pull requests are not guaranteed to be integrated. Before you build on it, read the Contributing section and the licence, which is listed as Mozilla Public License 2.0 in the credits, and note the last push was on 2026-09-09 with no tagged releases.

## FAQ

### What is Mitos and what does it do?

It is an ASCII art generator built by Oxide Computer Company that converts images, GIFs and custom JavaScript code into ASCII text illustrations, with a live-code option. It is used for producing branded ASCII graphics, and a live version runs at mitos.shared.oxide.computer.

### Which sources can Mitos generate ASCII art from?

Three: images, GIFs and custom JavaScript code. The custom code option lets the artwork be parameterised, and the README notes a live-code option alongside it for interactive adjustment.

### What are the preprocessing and display controls in Mitos?

Preprocessing controls cover brightness, contrast, dithering and inversion, and the ASCII character sets are customisable. The interface adds real-time preview with zoom and pan, animation support with playback controls, a grid overlay and multiple export options.

### How do I run Mitos locally?

Clone the repository and enter it, run bun install to install the dependencies, then bun run dev to start the development server. The project uses Bun throughout, including for the test runner and the lockfile.

### Is Mitos suitable as an external dependency for another project?

The README states that in its present state Mitos is an internal tool for Oxide Computer Company, tightly coupled to Oxide's design system, and that the authors cannot guarantee all pull requests will be integrated. The credits list Mozilla Public License 2.0 while the repository licence metadata is not stated, so both the coupling and the licence terms need resolving before adoption.

## Sources

- [Issues](https://github.com/oxidecomputer/mitos/issues)
- [oxidecomputer/mitos on GitHub](https://github.com/oxidecomputer/mitos)
- [Project website](https://mitos.shared.oxide.computer/)
- [README](https://github.com/oxidecomputer/mitos/blob/main/README.md)

---

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