# GitAnimals turns GitHub activity into SVG pets you embed in a README
> GitAnimals is a Kotlin service whose whole interface is an image URL: 30 commits adopt a new pet, contributions level it up, and three rendering modes produce an animated SVG or a farm or guild image for any README.
**git-goods/gitanimals** โ ๐ฃ ๊นํ๋ธ ํ๋์ผ๋ก ํซ์ ํค์ฐ์ธ์ / Have pet in your github
- Repository: https://github.com/git-goods/gitanimals
- Website: https://gitanimals.org
- Stars: 1,791 ยท Forks: 63
- Language: Kotlin
- License: NOASSERTION
- Published: 2026-10-16 ยท Updated: 2026-10-16 ยท Language: en
- Canonical page: https://hysenlabs.com/projects/git-goods-gitanimals
## 30 commits buys a pet, contributions raise its level
GitAnimals is a game layer over GitHub activity data. The rules are stated without ambiguity: commit 30 times and you adopt one additional pet, a single contribution increases the level of a random pet by one, and you can trade the pets you raise with other people. There are more than fifty pet types to draw and raise. The homepage at gitanimals.org is where you trade pets, buy backgrounds and create guilds.
There is a second acquisition route, and it is the more interesting one from a design standpoint. You can buy a pet from another user with commit points, and commit points are granted per commit. You can also sell your own pets to earn more of them. That turns the commit counter into a currency with a secondary market attached, and it is why the project is more than a static badge.
The cap matters for anyone rendering a profile. The maximum number of pets you can hold is 30, and anything beyond that goes into the inventory, where the homepage lets you swap which pet is displayed. The rendering endpoint then shows the selected subset, not the whole collection.
Contributions are the total accumulated since joining GitHub, and one caveat is called out: a new contribution can take up to one hour to be reflected. Anything that updates on a cron cycle eventually disagrees with the profile page for a while.
## Three image endpoints: lines, farms and guilds
The integration surface is the render service at render.gitanimals.org, and it offers three modes.
Line mode animates one chosen pet moving across a box you define. The width and height of the image element are the movement area, which is the whole configuration model: a wide, short box such as width 1000 and height 60 makes the pet travel horizontally, and a narrow, tall box such as width 60 and height 1000 makes it travel vertically. If the pet is not visible, the documented fix is to make the image height comfortably larger than the pet's own height.
There is a real trap in line mode. With a Markdown image request, you cannot set width and height, so the pet may not be visible. The README recommends using HTML.
Farm mode shows every animal you own plus extra information, and takes no configuration beyond the username. Guild mode draws a guild, which you create and manage with friends.
Each of these is one HTML block. Line mode, with the username substituted:
```html
```
Farm mode is the same idea without the query string:
```html
```
And guild mode takes the guild identifier in the path:
```html
```
## Finding the right pet-id through the users API
The `pet-id` query parameter is how you choose which pet line mode draws, and leaving it empty takes the first pet you own. To find the values, request the user endpoint with your own GitHub handle substituted for `{username}`, then read the `id` value under `$.personas.[].id` in the response. Each of those values is what you pass as `pet-id`.
One option controls what is drawn above the pet. In line mode, the total contributions count appears above the pet level by default, and if you do not want that, you add `contribution-view=false` as a query parameter.
The username requirement is strict in a way worth noting: the README states that `{username}` must contain your own GitHub name, so an alias will not resolve. That constraint is what lets the service find your contribution data at all.
The pets themselves are SVG files in a `docs/` directory in the repository, with a ratio column in the table: a common pet can sit at a ratio of 0.01 while RUDOLPH, a 2025 Christmas pet designed by a community contributor, is listed at 0.001. Some entries are marked Evolution and are only obtainable that way, such as PIG_ROBOT and GOOSE_ROBOT. So the collection is partly a drop-rate table and partly a set of unlocks, which is a different design from a flat rarity list.
## A Kotlin modular monolith with a Gradle build and translated READMEs
The repository is a Kotlin project built with Gradle, with `build.gradle`, `settings.gradle`, `gradle.properties` and the wrapper scripts checked in, plus a `deploy/` directory and a `scripts/` directory. The `src/` layout is where the structure is, and the topic tags describe the intended architecture rather than the feature set: ddd and modular-monolith are listed alongside decorate, decoration, fun, funny, game, pets and svg.
Those two tags are the interesting ones. A modular monolith with domain-driven design is a heavier commitment than a small image service usually makes, and it tells you the maintainers expect the codebase to grow rather than stay a single renderer.
The pet assets are SVG, which is consistent with the idea. Vector output scales to any README size and animates without a raster pipeline, and the repository ships a `fox.svg` at the top level alongside the pet collection.
Documentation is unusually multilingual for a project of this size. The README has dedicated translations for English, Korean, Simplified Chinese and Japanese, each as a separate file such as `README-en.md` and `README-zhcn.md`. That is a signal about audience rather than engineering, and it is consistent with a project whose user-facing surface is entirely inside a README.
There is also a `skills/` directory and a `deploy/` directory, plus `nohup.out` committed at the top level, which is the kind of stray file that tells you more about a project's habits than its architecture diagram does.
## Version 2.5.3, a custom licence, and a last push in April 2026
The maintenance picture needs stating plainly. The most recent tagged releases are 2.5.3 on 2025-12-25, 2.5.2 on 2025-11-23, and 2.2.6 on 2025-07-20, so the release line moved through 2025. The last push to the repository was on 2026-04-25, and the repository is not archived, but that push is close to six months before today and there is no newer tag behind it.
That combination has a direct consequence for anyone using it. A profile image is an embedded URL that can stop rendering at any time, and nobody watching a README will notice until it happens. Treat the embed as decoration you can lose rather than a dependency you can rely on, and be prepared to remove the image block rather than debug it.
The licence is recorded as a custom one GitHub cannot classify, with `LICENSE.md` at the repository root. That is worth reading directly rather than assuming a standard licence, particularly since the service is rendered by the maintainers rather than hosted by you.
The service also depends on GitHub activity data that GitHub itself controls. If the contribution source changes, the pet levels change with it, and the project would have no local copy of that data to fall back on.
## What GitAnimals is not, and what to compare it against
Three limits are obvious from the design.
It is not a metrics or insights tool. A contribution graph tells you activity over time; GitAnimals turns the same number into a level and a decoration. If you need to answer a question about your own commit history, this project cannot.
It is not self-hostable as the README presents it. The rendering happens on render.gitanimals.org, and the URLs in a README point at that host. The repository contains the Kotlin service source, but the README documents no way to run your own instance, and the pet image URLs would need to be rewritten to your own domain for that to be worth doing.
The realistic alternative for the same job is a static image or badge you generate yourself and commit to the repository. That approach has no service to depend on and no lag, but it also does not change, and it cannot level up. A common third option is a contribution graph image, which conveys activity without the collectible layer.
So the choice is not technical so much as a question of what you want on the page. If you want a profile decoration that moves and grows with your commits, GitAnimals does that and nothing else does. If you want information, one of the alternatives will serve you better.
## Conclusion
GitAnimals fits a public GitHub profile or a team README that wants a small animated decoration generated from real contribution data, because the entire integration is one HTML image tag and the render service needs nothing from your machine. It is not a dashboard, a metrics tool or a productivity system, and anyone whose commit counts are sensitive or auto-generated should not put it in a public profile. Before embedding it, replace `{username}` with your GitHub handle in one of the three URLs, request `https://render.gitanimals.org/users/{username}` to read the `$.personas.[].id` values for `pet-id`, and remember the last push to the repository was on 2026-04-25, so a profile image can break without much warning.
## FAQ
### How do I put a GitAnimals pet in my GitHub README?
Paste an HTML image block that points at render.gitanimals.org and replace `{username}` with your own GitHub handle. Use HTML because the README warns that a Markdown line-mode image cannot set width and height, so the pet may not be visible.
### How do I find my pet-id for line mode?
Request `https://render.gitanimals.org/users/{username}` with your own GitHub id and read the values under `$.personas.[].id` in the response. Pass one of those as the `pet-id` query parameter; if you leave it out, the first pet you own is used.
### How do I get more pets in GitAnimals?
Two routes: commit 30 times to adopt an additional pet, or buy one from another user with commit points, which are granted per commit. You can also sell your own pets for points, and the maximum number of pets you hold is 30, with extras going to the inventory.
### How long does it take for a new GitAnimals contribution to appear?
Total contributions are the sum accumulated since joining GitHub, and the README notes that reflecting a new contribution can take up to one hour.
### Can I hide the contribution count in GitAnimals line mode?
Yes. Line mode shows the total contributions above the pet level by default, and you can turn it off with the query parameter `contribution-view=false`.
## Sources
- [git-goods/gitanimals on GitHub](https://github.com/git-goods/gitanimals)
- [Issues](https://github.com/git-goods/gitanimals/issues)
- [Project website](https://gitanimals.org)
- [README](https://github.com/git-goods/gitanimals/blob/main/README.md)
- [Releases](https://github.com/git-goods/gitanimals/releases)
---
Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/git-goods-gitanimals