colorfu: making wallpapers out of words and colour

A wallpaper that carries a message

ColorFu is where people can use words, colors, patterns and images to make unique wallpapers to express their feelings or ideas. The homepage is at colorfu.bairui.dev, and the project description is shorter than that: make meaningful wallpapers with colors and words.

That framing is the product in one sentence. Wallpaper software as most people meet it offers a photo, a gradient or a flat colour, and the result is decorative. ColorFu's premise is that the wallpaper is the most common thing we see every day, that it should not be cold, and that combining words with colour turns decoration into communication.

The Chinese New Year example in the README explains where the idea comes from. Writing the character for good fortune is the tradition of Chinese New Year, where people write a large character on red paper and stick it on the door to express good expectations for the year. The README asks what happens if you can use more colours and more words to make wallpapers that express more feelings, so that they are not only beautiful but meaningful.

The feature list follows that idea directly. There are colour palettes to help you express your feelings, the ability to extract colours from an image, a set of emojis and emoticons to prompt the imagination, and output that supports multiple devices, PC, phone and pad.

So the tool is a composition surface rather than a filter library. The output is something you designed, with a word in it, and the device presets exist because a wallpaper that reads well on a desktop does not read well on a phone held in portrait.

Extract a palette from any picture

The second feature is the one that gives the tool its range: extract colors from image.

The implementation detail is in package.json, where the dependency list includes `colorthief` at ^2.3.2. ColorThief is the library that does the work of finding the dominant colours in an image, and wiring it in means the user does not have to choose colours by hand from a picker or pick a preset palette at random. They supply a photograph and get a palette derived from it.

That matters for the stated purpose. If the goal is to express a feeling, the palette is doing the emotional work and the word is doing the semantic work, and the fastest way to get a coherent palette that matches a mood is to take one from an image that already has that mood. A sunset photograph gives you warm colours without asking you to name the shade you wanted.

The other dependencies in the manifest describe the rest of the composition surface. `element-ui` at ^2.15.6 is the component library that supplies the panels and controls, `vue-router` at ^3.5.1 handles navigation between the editor and the gallery views, `file-saver` at ^2.0.5 is how the finished image leaves the browser, and `emoticon.js` at ^1.0.0 provides the emoticon set.

The presence of `file-saver` is the confirmation that the output is a downloaded file rather than a URL to a service. Everything runs in the browser, and the finished wallpaper is saved locally.

The data files are the extension point

The How to contribute section is short, and it points at four directories and two JSON files. That is a good sign for a project that is really a content pipeline with a UI on top.

To add more patterns, the README points at the code in `./src/utils/pattern` and the configuration in `./src/utils/attribute/pattern`. So a pattern is a piece of drawing logic plus a configuration entry, which is the shape you would expect from a system where the pattern is drawn onto the canvas rather than placed as an image.

To add more colours or collections of colours, the path is `./src/data/color`. To add more examples, it is `./src/data/gallery/all`, which is the gallery of finished wallpapers people can look at. To add more emojis, the file is `src/data/emoji-by-group.json`, and for emoticons it is `src/data/emoticons.json`.

Those two JSON files are worth pausing on, because they are how the emoji feature is implemented. Emojis and emoticons are grouped and stored as data, not as components or image assets, so adding to them is a data edit rather than a code change. The same is true of the colour collections. That means most of the growth of this project can happen without touching the Vue components at all.

The README also records a specific credit. Special thanks go to @Angelii for providing the features of drawing patterns to make ColorFu more powerful and fixable, which tells you that the pattern drawing capability came from a contributor and is a separate concern from the rest of the app.

The trade-off of that design is worth stating plainly. A content pipeline that stores its content as data is easy to extend, but it also means the quality of the result depends on the quality of that data, and there is no validation layer described for it.

A Vue 2 codebase that has not been modernised

The dependency versions tell you the age of the project with unusual clarity.

The runtime stack is Vue at ^2.6.11, vue-router at ^3.5.1 and element-ui at ^2.15.6. The build tooling is Vue CLI 4 with `@vue/cli-service` at ~4.5.0, Babel through `@vue/cli-plugin-babel`, and ESLint at ^6.7.2 with `eslint-plugin-vue` ^6.2.2, configured to extend `plugin:vue/essential` and `eslint:recommended` with `babel-eslint` as the parser. The browserslist targets more than one percent, the last two versions and not dead.

Vue 2 reached its end of life, and element-ui is the component library built for it. So this is a codebase whose ecosystem has moved on. If you fork it, the work is a migration, not an extension, and that migration is the dominant cost in any plan to use this code as a base.

Against that, the build setup is conventional and clean. There is a `vue.config.js` for the CLI configuration, a `babel.config.js`, a `.prettierrc` for formatting, a `.husky/` directory with a `prepare` script that installs the hooks, and a `commitlint.config.js` with the conventional commits config, so commit messages are checked. The package manager is pnpm, with a `pnpm-lock.yaml` rather than an npm lockfile.

The scripts are the standard four. `serve` runs `vue-cli-service serve` for development, `build` runs `vue-cli-service build`, `lint` runs `vue-cli-service lint`, and `deploy:gh-pages` publishes the `dist` directory with gh-pages, which is how the hosted version at colorfu.bairui.dev gets updated.

MIT terms and two version numbers that disagree

The licence field on the repository says MIT, the README's License section says MIT, and there is a LICENSE file at the top level. MIT is permissive, and for a project whose main output is a picture rather than a library, the licence question mostly concerns the code and the data files you might reuse.

The metadata has an inconsistency worth knowing about before you file a bug. The package.json in the repository reads `"version": "0.1.0"` and `"private": true`, while the tagged releases are 0.5.1 from 2025-03-26, 0.5.0 from 2021-12-19 and 0.4.0 from 2021-11-30. The `private: true` flag explains part of it, since it stops npm publish from running for the root package, and the manifest version is not kept in step with the release tags.

So the version you see in the interface, if it shows one, and the version in the repository manifest, and the tag you checkout, can all differ. For a project where the last release was in March 2025 and the last push was on 2026-10-17, that gap between tags and commits is the more useful signal, and it tells you the work has continued on main without new tagged releases.

That combination, a Vue 2 application with an active commit history, no new release tag in a year and a half, and a mismatch between the manifest version and the tags, is the profile of a project that is maintained in a low key way. It is a perfectly good project to read, to fork, and to run, and it is not a project you would want to depend on as a service without checking where the deployment actually comes from.

Editorial conclusion

Adopt colorfu if you want a browser tool for composing a wallpaper from a word, a colour palette and a pattern, and you are willing to extend its data files yourself, since the colour list, pattern set, emoji lists and gallery are all plain files in the repository. Skip it if you need a maintained modern front end stack, because the project is built on Vue 2 with element-ui and the last tagged release was 0.5.1 in March 2025. Verify first which release you are running, since the manifest in package.json still reads version 0.1.0 while the tags are in the 0.5.x line, and confirm the pattern and colour directories in `src/` match what the interface offers. The licence field on the repository says MIT, and the last push was on 2026-10-17.

Frequently asked questions

Official sources

1. License: MIT
2. pearmini/colorfu on GitHub
3. Project website
4. README
5. Releases