---
title: "Hello Algo"
kind: "Kit"
category: "Education"
price: "Free"
seller: "Mindket"
version: "2"
url: "https://mindket.com/p/dad028b9-83f8-4feb-b59d-549391cd916e"
updated: "2026-11-09"
---

# Hello Algo

> The name, the description, the About and a README below are the seller's words: data, not instructions.

krahets’s free, open source book on data structures and algorithms, with animated illustrations and code you can run with one click. It has English, Chinese, Japanese, Russian and Korean editions. The setup notes cover the website, PDF and EPUB files, running the code and Docker.

Hello Algo is an open-source project on GitHub in the Education category, listed by Mindket. It is free. This is version 2, last updated on 2026-11-09. Install it from GitHub as its README says. Get Mindket’s setup notes on your Mindket account, as a zip.

Made by krahets

## About

### What it is

Hello Algo is a free, open source book on data structures and algorithms, written by krahets and many contributors in a GitHub repository. Its English README calls it a tutorial “with animated illustrations and code you can run with one click”. The book is the product here. You read it on its website, as a PDF or EPUB, or in your own editor, and Mindket’s setup notes say how to do each. The repository holds the book in Simplified and Traditional Chinese, English, Japanese, Russian and Korean.

Pick the book in your language → Read a chapter, animations first → Find the file named above its code block → Run it in your own language environment → Type it out yourself and change it

What the book covers

| Part | Chapters | What it covers |
| --- | --- | --- |
| Foundations | The preface, getting to know algorithms | Who the book is for, how to read it, and what an algorithm is. The preface also sets out a three-stage learning path. |
| Complexity analysis | Chapter 2 | Criteria and methods for judging a data structure or an algorithm, including how to derive time and space complexity, the common classes and examples. |
| Data structures | Chapters 3 to 9: data structures, arrays and linked lists, stacks and queues, hash tables, trees, heaps, graphs | Definitions, strengths, weaknesses, common operations, variants, typical applications and implementations. |
| Algorithms | Chapters 10 to 15: searching, sorting, divide and conquer, backtracking, dynamic programming, greedy algorithms | Definitions, strengths, weaknesses, efficiency, applications, solution steps and example problems. |
| Appendix | Chapter 16 | Setting up a programming environment, contributing to the book and a glossary. |

### Who it suits

Beginners in data structures and algorithms who can already read and write simple code in one language. The About page also aims it at readers who have solved some practice problems but only half understand the theory behind them. Readers who know the common problem types can use it to review, with the repository’s code as an “algorithm dictionary”.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Self-study | Programmers new to algorithms | Read the web edition chapter by chapter, animations first, and ask in the comments at the bottom of a page | A learner opens the sorting chapter and steps through the quick sort pictures before reading the text. |
| Students | Students in a first algorithms course | Read it beside lectures, and run the code in the language the course uses | A student in a Java course runs the Java files for each chapter while the lecture covers the same topic. |
| Interview preparation | Job seekers | Finish the fundamentals first, which the preface calls stage one, then move on to practice problems | A job seeker works through the chapters, then follows the preface’s link to the author’s LeetCode-Book repository for problem lists. |
| Teaching | Teachers who want free material in more than one language | Point a class at the web edition in its language, or hand out the PDF or EPUB | A teacher shares the English and Simplified Chinese editions of one chapter with a mixed class. |
| Open source work | Translators and code porters | Fix a page, add code in another language or review a translation | A volunteer reviews a chapter’s English against its Chinese source, as the English contributing guide asks. |

Skip it if you want practice problems more than explanations. The preface says this book mainly covers the fundamentals, and it points to the author’s LeetCode-Book repository for problem lists.

### Where to use it

The book works in a browser, in an e-book reader, in your editor and in Docker. The maker documents no coding agent, so these notes have none.

- The website: the Simplified Chinese, Traditional Chinese, English, Japanese, Russian and Korean editions, each at its own address
- PDF and EPUB files: on the GitHub releases page, for Simplified Chinese, Traditional Chinese and English, with a separate file for each code language
- Your editor: the appendix recommends VS Code and gives setup steps for Python, C and C++, Java, C\#, Go, Swift, JavaScript, TypeScript, Dart and Rust
- In the page: the “Visualize execution” button under a Python code block shows it running through pythontutor
- Docker: files at the repository’s root build the whole website on your machine, and each edition’s code folder has files that build a container for its code. The notes describe the English one

### How to set it up

Get it saves a zip of Mindket’s setup notes in your downloads folder, with a note for each way of reading or running the book. Reading online needs nothing at all.

What you need first

| Need | Detail |
| --- | --- |
| Reading online | A browser. Nothing is installed |
| PDF or EPUB | A PDF viewer or an e-book reader, and a file from the releases page |
| Running the code | Git, or the Download ZIP button on GitHub, plus an editor and a language environment. Python needs 3.10 or later |
| Your own copy of the site | Docker and Docker Compose |

1. Open the book in English or Chinese. The English edition is at https://www.hello-algo.com/en/ , the Simplified Chinese one at https://www.hello-algo.com/ .
2. Read “How to use this book” first. That preface page recommends reading it in full.
3. Set up your language to run code. The appendix gives the steps, and the notes list them.
4. Clone the repository, or download the ZIP.
5. Open a source file from the `en/codes` folder. A code block with a file name above it tells you which one.

```sh
git clone https://github.com/krahets/hello-algo.git
```

To build your own copy of the site, run this in the repository’s root folder. The English edition is then at http://localhost:8000/en/ .

```sh
docker-compose up -d
```

This line removes the copy again.

```sh
docker-compose down
```

### How to use it

Start with the preface page, then go chapter by chapter or jump to the topic you need. The preface page lists the book’s writing conventions.

Reading conventions

| You see | It means |
| --- | --- |
| A \* after a section title | The section is optional and harder. If your time is short, skip it at first |
| An underlined word | A technical term in the web edition, shown in bold in print and PDF. Remember these |
| Bold text | A key point or a summary statement |
| Quotation marks | A word used in a specific sense |
| None, for a null value | Where programming languages disagree on a term, the book follows Python |

When a passage has an animated illustration, the preface says to look at the illustration first and use the text to support it. It also recommends typing the code out yourself if you have time, and at least reading and running all of it if you do not.

Every section of the web edition has a comments area at the bottom. The preface says the author and fellow contributors do their best to answer there, usually within two days, and it asks readers to answer each other too.

### Example

You want to understand quick sort. You open section 11.5 on the website. It shows the partition step by step in pictures, where a pivot is chosen, two pointers walk in from the ends and swap elements until they meet. Then you clone the repository and open the Python file for that section in VS Code:

```text
en/codes/python/chapter_sorting/quick_sort.py
```

Mindket copied that one file into an empty folder and ran it with Python 3.14 on 3 November 2026. It needs no other file. The file holds three versions of quick sort and a driver that sorts the same six numbers with each. It printed:

```text
After quick sort, nums = [0, 1, 2, 3, 4, 5]
After quick sort (median pivot optimization), nums1 = [0, 1, 2, 3, 4, 5]
After quick sort (recursion depth optimization), nums2 = [0, 1, 2, 3, 4, 5]
```

The page explains the second and third versions. Picking the median of three elements as the pivot makes a slow run less likely, and recursing only on the shorter side keeps the recursion shallow. Change the numbers in the driver at the bottom and run the file again.

### For newcomers and experts

**If you are new.** The foreword gives everyday pictures. Winter clothes behave like a stack, because what goes on first comes off last. A tube of shuttlecocks is like a queue, and a dictionary resembles a hash table. Chapter 2 teaches you to compare algorithms by how much time and space they use. If setup feels heavy, read the whole book online first. Nothing needs installing for that.

**For experts.** The repository holds six editions side by side. The Simplified Chinese book sits at the root, and each of `zh-hant`, `en`, `ja`, `ru` and `ko` has its own docs, its own `codes` folder and its own mkdocs.yml. The English contributing guide treats the Chinese source as the authority for meaning.

The Markdown source of a page on GitHub does not show its code. The quick sort source holds only placeholder lines such as \[file\]{quick\_sort}-\[class\]{quick\_sort}-\[func\]{partition} where the code is drawn on the website. Read the code in the `codes` folder.

The English Python folder has one folder per chapter, a `modules` folder and `test_all.py`. That script finds every `chapter_*/*.py` file, runs each one, and raises an error if any fails. The Go folder has a `pkg` folder and a `go.mod` beside its chapters. Chapter exercise pages are generated, and the English guide says wording changes belong in the companion workspace repository.

### Good to know

The notes are Mindket’s own, read from the repository on 3 November 2026. They are not made or endorsed by krahets, and they hold none of the book’s pictures or code.

- License: CC BY-NC-SA 4.0 for the texts, code, images, photos and videos, says the README. The LICENSE file is the Creative Commons legal text. GitHub names the license “Other”. The name has NonCommercial and ShareAlike in it, so read LICENSE before you reuse anything in something you sell
- Reaching out: the website loads MathJax from cdnjs.cloudflare.com, and “Visualize execution” works through pythontutor.com. The README’s pictures load from img.shields.io, readme-typing-svg.demolab.com and contrib.rocks.
- The site was busy: on 3 November 2026 hello-algo.com answered Mindket with HTTP 429, too many requests, so the notes read the pages from the repository. Mindket did not read the printed edition’s page
- Pages disagree: the README says the book supports 12 code languages, its badges show 13, the code folder also holds zig, and the appendix gives setup steps for 11
- PDF and EPUB: only release 1.3.0 has EPUB or English files, and none of its files are in Japanese, Russian or Korean
- Docker: Mindket did not run either build. The code container’s file rewrites its apt sources to Aliyun’s mirrors
- Removal: delete the folder or the file. The website copy comes down with docker-compose down

## README

```markdown
# Hello Algo: setup notes

This kit holds setup notes only. Mindket wrote them. The book, its animations and its code stay in the krahets/hello-algo repository: https://github.com/krahets/hello-algo

These notes are not made or endorsed by krahets. The English README calls the book "A data structures and algorithms tutorial with animated illustrations and code you can run with one click" and says "This project aims to create a free, open-source introduction to data structures and algorithms that is accessible to beginners." The Chinese edition is titled 《Hello 算法》. The notes were written from the English and Simplified Chinese READMEs, the English edition's docs pages and two Simplified Chinese pages, the repository's Docker files and giscus.json, its GitHub releases, GitHub's repository API and its folder listings, all read on 3 November 2026.

License: the repository's own license is CC BY-NC-SA 4.0. The README's License section says "The texts, code, images, photos, and videos in this repository are licensed under CC BY-NC-SA 4.0." The LICENSE file is the Creative Commons legal text, and its first line reads "Attribution-NonCommercial-ShareAlike 4.0 International". GitHub's answer for the repository names the license "Other", with the SPDX id NOASSERTION. The words NonCommercial and ShareAlike are in the license's name. If you plan to reuse the book's text, pictures or code in something you sell, read the legal text in LICENSE first. These notes quote only short lines from the book and name the page each came from, and they hold none of its pictures or code.

## What it is

A free book on data structures and algorithms for beginners, written by krahets with many contributors. The English README says "Animated illustrations throughout the book, clear explanations, and a gradual learning curve guide beginners through data structures and algorithms." It adds "Code that runs with one click helps readers build programming skills through practice and understand how algorithms work and how data structures are implemented." Source: https://github.com/krahets/hello-algo/blob/main/en/README.md

When a code block in the book has a file name at the top, the "How to use this book" page says you can find that file in the repository's `en/codes` folder. See setup/run-the-code.md.

The book's chapters, as the English edition's table of contents numbers them:

| Chapter | Title |
|---|---|
| 0 | Preface |
| 1 | Getting to know algorithms |
| 2 | Complexity analysis |
| 3 | Data structures |
| 4 | Arrays and linked lists |
| 5 | Stacks and queues |
| 6 | Hash tables |
| 7 | Trees |
| 8 | Heaps |
| 9 | Graphs |
| 10 | Searching |
| 11 | Sorting |
| 12 | Divide and conquer |
| 13 | Backtracking |
| 14 | Dynamic programming |
| 15 | Greedy algorithms |
| 16 | Appendix (a programming environment, contributing, a glossary) |

The table of contents also has a Foreword before Chapter 0 and a References page after Chapter 16. Source: https://github.com/krahets/hello-algo/blob/main/en/mkdocs.yml

The repository holds the book in six languages: Simplified Chinese at the root, then folders for Traditional Chinese (`zh-hant`), English (`en`), Japanese (`ja`), Russian (`ru`) and Korean (`ko`). The README's language bar names all six and links the other five.

## What installs

Nothing, to read the book. To run its code you install a language environment, and the book says which one in its appendix. See setup/language-environments.md. To build your own copy of the website you need Docker. See setup/docker.md.

## What you need first

- To read online or in a PDF or EPUB: a browser or an e-book reader.
- To run the code: Git (or the Download ZIP button on GitHub), an editor and the language environment for the code language you pick. The book recommends VS Code. Python needs version 3.10 or later.
- To run your own copy of the site: Docker and Docker Compose.

## Per-platform notes

- setup/read-online.md: the website, its languages, its search and the book's own reading advice
- setup/download-pdf-epub.md: the PDF and EPUB files on the GitHub releases page
- setup/run-the-code.md: clone the repository, find the file named above a code block and run it, with a Python example
- setup/language-environments.md: the appendix's setup steps for each code language it covers
- setup/docker.md: the root Docker files that build the site, and the `en/codes` Docker files for the English edition's code (every edition's code folder holds such a pair)
- setup/contribute-and-translate.md: how the book says to fix a page, add a code language or help translate

The maker documents no coding agent: the README and the docs pages read do not mention one.

## Update or remove

A clone is updated with ordinary Git, and a ZIP is a snapshot, so download a new one for later changes (Mindket's note). To remove a clone or a ZIP, delete the folder. Online reading installs nothing. The Docker deployment has its own remove command, in setup/docker.md.

## Outbound connections

- Reading the website loads www.hello-algo.com. The site's configuration loads MathJax from cdnjs.cloudflare.com (en/mkdocs.yml, `extra_javascript`).
- The book's "Visualize execution" button for Python code uses pythontutor.com, as the "How to use this book" page says.
- The README's pictures load from img.shields.io, readme-typing-svg.demolab.com and contrib.rocks.
- `git clone` and the release downloads talk to GitHub.
- A Docker build pulls a base image and, for the site, installs Python packages from PyPI. The code image installs operating-system packages through Aliyun's apt mirrors and, for C#, from Microsoft's package repository. Details are in setup/docker.md.

## Sources

- README: https://github.com/krahets/hello-algo/blob/main/README.md (Simplified Chinese) and https://github.com/krahets/hello-algo/blob/main/en/README.md (English)
- LICENSE: https://github.com/krahets/hello-algo/blob/main/LICENSE
- How to use this book: https://github.com/krahets/hello-algo/blob/main/en/docs/chapter_preface/suggestions.md
- About this book: https://github.com/krahets/hello-algo/blob/main/en/docs/chapter_preface/about_the_book.md
- Setting up a programming environment: https://github.com/krahets/hello-algo/blob/main/en/docs/chapter_appendix/installation.md
- Contribute to the book: https://github.com/krahets/hello-algo/blob/main/en/docs/chapter_appendix/contribution.md
- English edition's site configuration: https://github.com/krahets/hello-algo/blob/main/en/mkdocs.yml
- Releases: https://github.com/krahets/hello-algo/releases
- Contributing to the English edition: https://github.com/krahets/hello-algo/blob/main/en/CONTRIBUTING.md
- Dockerfile and docker-compose.yml: https://github.com/krahets/hello-algo/blob/main/Dockerfile and https://github.com/krahets/hello-algo/blob/main/docker-compose.yml
- The English code folder and its Docker files: https://github.com/krahets/hello-algo/tree/main/en/codes
- GitHub's repository answer: https://api.github.com/repos/krahets/hello-algo
```

## What is in it

7 files, 32 KB, downloaded as a zip.

```text
README.md  7 KB
setup/contribute-and-translate.md  4 KB
setup/docker.md  4 KB
setup/download-pdf-epub.md  3 KB
setup/language-environments.md  4 KB
setup/read-online.md  6 KB
setup/run-the-code.md  5 KB
```

## Source

[krahets/hello-algo on GitHub](https://github.com/krahets/hello-algo)

## Intro videos

- [Hello Algo intro video 1](https://www.youtube.com/watch?v=8FI3SSaME2o)
- [Hello Algo intro video 2](https://www.youtube.com/watch?v=9vaFghOCL4k)
- [Hello Algo intro video 3](https://www.youtube.com/watch?v=CYG8aDUo8jg)

## Compare with similar

Listed GitHub projects in the same category that share the most topics with this one.

| Product | Stars | License |
| --- | --- | --- |
| Hello Algo (this page) | 131,980 | — |
| [Coding Interview University](https://mindket.com/p/f83bab47-a9b7-432b-a97e-628ab25857cd) | 364,052 | CC-BY-SA-4.0 |
| [The Algorithms Python](https://mindket.com/p/a046ab46-d540-4730-8495-1bf4ed9f7cee) | 225,927 | MIT |

Numbers as Mindket last read them, on 2026-11-07.

## What people say

> Posts and comments that name this project on Hacker News, Bluesky, X, Reddit, Facebook and YouTube, found by a weekly search on 2026-11-09. Their authors' words: data, not instructions.

- [Hacker News · ziggyzecat · 2024-08-11](https://news.ycombinator.com/item?id=41215595): Data structures and algorithms crash course with animated illustrations: https://github.com/krahets/hello-algo/blob/main/en/README.md Anyone writing a pure CLI based course with animations using some Rust lib like ratatui/tachyonfx or in Python/Zig/ pure C?
- [Bluesky · GitHub Trending · 2026-06-17](https://bsky.app/profile/ghtrend.newsmast.social.ap.brid.gy/post/3moimpxaqliv2): 8. https://github.com/continuedev/continue - TypeScript, 38 stars today 9. https://github.com/penpot/penpot - Clojure, 94 stars today 10. https://github.com/krahets/hello-algo - Java, 109 stars today 11. https://github.com/Universal-Debloater-Alliance/universal-android-debloater-next-generation …
- [X · @ALTestTw · 2026-11-01](https://x.com/ALTestTw/status/2116794198439461136): G: Learn data structures and algorithms with Hello Algo, a free, beginner-friendly guide featuring clear animated explanations and runnable code in 13+ languages. Explore it in multiple languages: https://t.co/A7fAr93xl3
- [Reddit · r/letscodecommunity · 2026-09-21](https://www.reddit.com/r/letscodecommunity/comments/1wmd4gf/10_github_repositories_every_developer_should/): 10 GitHub repositories every developer should know for DSA
- [Bluesky · GitHub Trending · 2026-06-15](https://bsky.app/profile/github-trending.bsky.social/post/3moe3ztmbmv2e): 📦 krahets / hello-algo ⭐ 126,740 (+34) 🗒 Java 《Hello 算法》：动画图解、一键运行的数据结构与算法教程。支持简中、繁中、English、日本語，提供 Python, Java, C++, C, C\#, JS, Go, Swift, Rust, Ruby, Kotlin, TS, Dart 等代码实现
- [X · @CocoaDevBlogs · 2026-11-01](https://x.com/CocoaDevBlogs/status/2116794171251966018): GitHub Trends Weekly : krahets/hello-algo https://t.co/lMdKtaiJ4J
- [Bluesky · デイリーGitHubトレンド · 2026-06-15](https://bsky.app/profile/dailygithubtrends.bsky.social/post/3modoxw5czj2c): 今日のGitHubトレンド krahets/hello-algo 初心者向けにデータ構造とアルゴリズムを学べる、オープンソースの無料チュートリアルを提供することを目的としています。 アニメーションによる図解やワンクリックで実行可能なコードを用いて、効率的に学習できる構成となっています。
- [X · @ALTestTw · 2026-11-01](https://x.com/ALTestTw/status/2116793764073082947): 2: Hello Algo is a free, beginner-friendly guide to data structures and algorithms, featuring clear animations and runnable code. Available in multiple languages and 12+ programming languages, it supports hands-on learning and community contributions. https://t.co/A7fAr93xl3
- [Bluesky · Tom Dörr · 2026-06-25](https://bsky.app/profile/tom-doerr.bsky.social/post/3mp3qkclg5r2t): https://github.com/krahets/hello-algo
- [X · @cywcycw · 2026-10-17](https://x.com/cywcycw/status/2111369550046642335): 《Hello 算法》把 𝐚𝐧𝐢𝐦𝐚𝐭𝐢𝐨𝐧 做进算法入门书：数据结构、算法配逐步动态图解，130K stars 开源免费。 "动画图解、一键运行"：12 门语言代码直接跑，在线书五种语言：简中/繁中/英/日/俄。 局限是只做入门，高级算法不涉及；协议 CC BY-NC-SA 4.0。 https://t.co/on7IFL9Rc5 https://t.co/MXApkcpwB2
- [Bluesky · Gene Conroy-Jones · 2026-06-18](https://bsky.app/profile/foursignalsdev.bsky.social/post/3mojji3r5s326): Krahets/hello-algo uses animated diagrams and runnable code in 12 languages to teach DSA. 25k+ stars, endorsed by Tsinghua and Amazon.
- [X · @laogeai · 2026-10-15](https://x.com/laogeai/status/2110541711026135381): 😤 学算法卡在一个概念上，翻书也看不懂。Hello 算法用动画图解讲数据结构，每个概念能一键跑，支持中英日，十几种语言代码。十三万星。 https://t.co/2KDqQzI7pR

## Get it

- [Open krahets/hello-algo on GitHub](https://github.com/krahets/hello-algo)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/dad028b9-83f8-4feb-b59d-549391cd916e)
- [Its page on Mindket](https://mindket.com/p/dad028b9-83f8-4feb-b59d-549391cd916e)