# XQuant Beginner: an open-source book whose exercises live in a second repository

> XQuant Beginner is a Chinese-language open-source book on quantitative trading built around a spec-first workflow where an AI writes the Python. This repository is a publishing pipeline rather than a strategy library, the notebooks ship elsewhere, and the newest manuscript is hosted off-site.

**xingwudao/xquant-beginner** — XQuant: Everyone Can Be a Quant Trader — an open-source beginner's book on quantitative trading, using AI and Python to build strategy backtesting, risk assessment, trade execution and factor research from scratch.

- Repository: https://github.com/xingwudao/xquant-beginner
- Website: https://xingwudao.github.io/xquant-beginner/
- Stars: 881 · Forks: 179
- Language: TypeScript
- License: NOASSERTION
- Published: 2026-09-17 · Updated: 2026-09-17 · Language: en
- Canonical page: https://hysenlabs.com/projects/xingwudao-xquant-beginner

## The repository holds the manuscript and the publishing config, not the code

The single most useful thing to know before browsing is what is not here. The top level is a book project: a `book/` directory, `index.md`, `public/` for images, `.vitepress/` and `.gitbook.yaml` for the two publishing targets, `SUMMARY.md` as the table of contents, `CHANGELOG.md`, `CONTRIBUTING.md`, `LICENSE`, and `scripts/`. There is no Python in it at all, which is why the repository's primary language reads as TypeScript. The exercises are deliberately kept elsewhere. The companion specs and notebooks are maintained in the xingwudao/xquant-learning repository, and the book text tells you that a path such as `q1-how-to-profit/specs/` should be looked up there rather than in the book repository. That split is deliberate rather than accidental, but it does mean a reader following the text has to move between two repositories from the first exercise onward.

## The dev server binds to every interface, not just localhost

The local preview instructions are four commands long, and one detail in them is worth noticing.

```bash
npm install
npm run docs:dev
```

The script behind that is `vitepress --host 0.0.0.0`, so the development server is exposed on every network interface rather than being confined to localhost. The preview command has the same flag. On a laptop joined to a cafe or office network that means anyone on the same segment can fetch the book while you have it running, and the dev server is a preview tool with none of the hardening a published site would carry. The build and preview pair is separate:

```bash
npm run docs:build
npm run docs:preview
```

The output lands in `.vitepress/dist/`, and there is a fourth script, `npm run seo:check`, which runs `node scripts/check-seo.mjs`. That is a signal about how the project is run: the site is treated as something that gets published, not just read.

## GitBook and VitePress read the same two files

The project publishes through two different pipelines from one source tree. GitBook publication uses `.gitbook.yaml`, `README.md` and `SUMMARY.md`. Static site publication goes through VitePress. Because both consume the same summary and readme, the table of contents exists once and both outputs inherit it, which is a small and sensible piece of engineering for a book that has to be readable in more than one place. The `package.json` is minimal and marks itself `private` at version `0.1.0`, with a single dev dependency on VitePress at `^1.6.4`. Two details in that file are more interesting than they look. There is an `overrides` block pinning Vite to the exact version `6.4.2`, which is the usual way to hold a transitive dependency in place when a site build depends on it behaving correctly. And because the package is private and never published, the version field carries no release meaning; the repository has no GitHub releases at all.

## The newest manuscript is advertised from a page this repository does not host

Read the quick-entry list carefully and a versioning question appears. The online book is at the GitHub Pages address, and then the text says the latest manuscript has been updated to the XQuant course page and that anyone wanting the latest official version should go to xquant.shop/courses. Courses, the formal book, and later updates are also placed on the main site. There is a second link to the same store, and the framing around it is aimed at readers who cannot write code or do not want to read the whole book: a portfolio store of ready-made strategies at xquant.shop/products. So the repository you are reading is the free and open edition, and the project's own pointer for current material leads off-site to a commercial destination. Nothing states which is ahead. That is the first thing to establish for yourself, because a curriculum that has been reorganised between the two will not map cleanly chapter to chapter.

## The dual licence splits the manuscript from the build tooling

GitHub reports no recognised licence for this repository, and the reason is the licensing scheme rather than an oversight. The project uses two. Manuscript text and images are CC BY-NC-SA 4.0. Build scripts, configuration files, and the automation workflows are MIT. The practical split is clean: attribution plus non-commercial plus share-alike for the writing, and a permissive licence for the machinery. The non-commercial clause is the part with teeth. You can translate, adapt, and redistribute the chapters provided you credit the authors, stay non-commercial, and license derivatives the same way, so the book is genuinely usable for study, internal training, or a non-profit course. Putting adapted chapters into a paid product is a different question, and the README does not document an exception for that. The authors themselves are named in the text, and the reader group is reached through a WeChat contact rather than a mailing list.

## The chapter order puts position size before entry timing

The curriculum is organised around ten items, a preparation chapter plus nine numbered ones, and the sequence is the interesting part rather than the titles. Chapter 1 covers how quantitative trading makes money and how to get a first strategy running. Chapter 2 is what to buy, meaning how a candidate universe is constructed. Chapter 3 is how much, which is weight allocation and position management. Only in chapter 4 does timing arrive, in the form of the trading rules for when to buy and sell. Chapter 5 asks how to tell whether the strategy works at all by evaluating the backtest. Chapter 6 is about self-deception and overfitting. Chapter 7 moves from backtest to actual execution, chapter 8 covers monitoring, diagnosis and iteration, and chapter 9 introduces factor research as the daily work. Sizing and universe before timing is an unusual order, and it is the clearest signal of what this book thinks beginners get wrong.

## The evaluation vocabulary is more specific than the Vibe Coding framing suggests

The learning method is described as vibe coding: you do not learn Python first, you describe the investment idea, an AI helps write and run the code, and then you use data to check whether the idea holds up. The framing is loose, but the vocabulary attached to the verification steps is not. The stated path runs from proposing an idea, to writing it as a specification, to having AI generate and run the Python, to fetching data and backtesting, to comparing against a benchmark and assessing return and risk, to checking for overfitting, data leakage, and parameter hallucination. Parameter hallucination in particular is a term you will not find in most quant introductions; it names the failure where a value gets an invented justification after the fact. The intended reader is stated plainly as someone who has read many strategy articles and still lacks a systematic method for backtesting and evaluation, and the book says outright that it is neither a collection of guaranteed-profit strategies nor a high-frequency trading tutorial.

## Conclusion

Treat XQuant Beginner as a curriculum with a documented order of study, not as a toolkit. The chapter sequence is the actual product: what to buy, then how much, then when, then whether any of it survives a backtest. Two things to check before you commit time. Confirm where the current manuscript lives, because the repository points readers to a commercial course page for the latest official version and the two can diverge. And read the license before you reuse anything, since the text is CC BY-NC-SA while the build tooling is MIT, which is a split that matters if you ever want to put the chapters in a commercial course. What you will not get is strategy code. The exercises are maintained in a separate repository, and the repository that names itself after the book contains a VitePress site, a GitBook configuration, and an SEO check script.

## FAQ

### Where do the XQuant Beginner exercises and notebooks live?

Not in the book repository. The companion specs and notebooks are maintained in the separate xingwudao/xquant-learning repository. When the book text shows a path such as `q1-how-to-profit/specs/`, look for the matching file there rather than in xquant-beginner.

### How do I build the XQuant Beginner site on my own machine?

Install Node.js, then run `npm install` followed by `npm run docs:dev`. Static output is produced by `npm run docs:build` and lands in `.vitepress/dist/`; `npm run docs:preview` serves the built result. Note that the dev and preview scripts pass `--host 0.0.0.0`, so they listen on all interfaces.

### What licence applies to the XQuant Beginner book text?

The repository uses two licences. Manuscript text and images are CC BY-NC-SA 4.0, meaning attribution, non-commercial use, and share-alike for derivatives. Build scripts, configuration files, and automation workflows are MIT.

### Does XQuant Beginner teach high-frequency trading or give ready-made profitable strategies?

Neither. The book states it is not a collection of guaranteed-profit strategies and not a high-frequency trading tutorial. Its focus is how an ordinary investor uses AI, data, and a clear experimental process to validate an investment idea of their own.

### Where can I read the latest version of the XQuant Beginner manuscript?

The open book is published at the GitHub Pages address. The text says the latest manuscript has been updated to the XQuant course page, and directs readers who want the latest official version to xquant.shop/courses, where courses, the formal book, and later updates are also posted.

## Sources

- [Issues](https://github.com/xingwudao/xquant-beginner/issues)
- [Project website](https://xingwudao.github.io/xquant-beginner/)
- [README](https://github.com/xingwudao/xquant-beginner/blob/main/README.md)
- [xingwudao/xquant-beginner on GitHub](https://github.com/xingwudao/xquant-beginner)

---

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