# Rustcrab is a free online Rust handbook whose landing page is a Next.js app

> Rustcrab is an open source project that collects what you need to learn Rust, and the repository pairs the book content with a Next.js and Tailwind site that shows the GitHub star count in real time, toggles light and dark mode and links out to daily.dev. It suits a learner who wants the material in one place, and it is a reading project rather than a Rust library.

**FrancescoXX/rustcrab** — An Open Source project with everything you need to learn about Rust.

- Repository: https://github.com/FrancescoXX/rustcrab
- Website: https://rustcrab.com
- Stars: 530 · Forks: 109
- Language: Rust
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/francescoxx-rustcrab

## Two things in one repository

The repository description is An Open Source project with everything you need to learn about Rust, and the README opens with the same line. The homepage is rustcrab.com.

The README then describes the site rather than the book, and that mismatch is the first thing to understand. This is a Next.js application with Tailwind CSS and TypeScript, which includes a real-time display of the number of stars on the GitHub repository and supports light and dark mode toggling, and it also integrates with daily.dev for additional developer resources.

So what you have is a learning project whose web presence is a landing page and handbook reader. The repository top level makes the split visible. There is book-compendium/ for the handbook content, rust-handbook-testimonials.md as a separate file at the root, and src/ for the Next.js application, with public/ for static assets.

The feature list is a list of the site's features rather than of a learning path. Real-time GitHub stars, light and dark mode, responsive design optimised for various screen sizes using Tailwind CSS, developer resources including links to daily.dev and the GitHub repository, social media integration with links to Twitter, LinkedIn, YouTube, Discord and Instagram, and Google Analytics integration to monitor real-time analytics.

That is a fairly thin feature set for a Next.js application, and it tells you the site is a wrapper, not the product. The product is the book-compendium directory and the Rust content it points at.

## Running it locally

The prerequisites are Node.js at version 14.x or later, and npm or yarn.

The install is the familiar two steps.

```bash
   git clone https://github.com/FrancescoXX/rustcrab.git
   cd rustcrab
```

```bash
   npm install
```

Or with yarn.

```bash
   yarn
```

Then the development server.

```bash
npm run dev
```

And open http://localhost:3000 to view the application.

The production build follows the same pattern.

```bash
npm run build
```

The README says this generates an out directory containing the optimized build, and that you can deploy the Next.js application to various platforms such as Vercel, Netlify, or any other hosting provider supporting static site hosting.

One thing to notice is that the README's Node.js 14.x prerequisite is out of date relative to the rest of the repository. The Dockerfile is based on node:20-alpine, and the TypeScript and Next.js versions in package.json are from the same period. If you follow the README literally and install Node 14, you will hit the package manager refusing to run a modern Next.js release. The prerequisite line is worth ignoring in favour of a current Node.

The package.json also shows the script set, which is the standard Next.js set plus a couple of additions. There is dev, build, start and lint, then ts and typecheck running tsc in slightly different modes, and format:fix and format:check using prettier across ts, tsx, json and css files.

## The dependency list and what it implies

The package.json is small and each dependency has an obvious purpose, which is worth walking through because it describes the site's behaviour.

Next 14.2.4 with React 18 and react-dom 18 is the framework and view layer. Tailwind CSS is at 3.4.1 with postcss 8 as the build step, and tailwind.config.ts and postcss.config.mjs are at the repository root.

Then the feature-specific packages. lucide-react and react-icons give you the icon set, and having both is a sign of a project that grew organically. canvas-confetti is the celebration effect, which is what a star count display uses when you click the star button. js-cookie is for persisting the theme choice in the browser, which is what makes the light and dark toggle survive a reload. react-syntax-highlighter at 15.5.0 is the code renderer, and for a site whose subject is a programming language, syntax highlighting of Rust snippets is not optional.

The typescript version is 5 and the eslint setup is 8 with eslint-config-next matching the Next.js version.

That last dependency, react-syntax-highlighter, is the clearest hint about what the site actually renders. A landing page with a star counter does not need a syntax highlighter. A handbook that displays Rust code does, and that is consistent with the book-compendium directory being the substance of the project.

The version in package.json is 0.2.1, matching the last listed release v0.2.1 from 2024-10-01, with v0.2.0 from 2024-08-30 before it. The last push to the repository was on 2026-05-09.

## The Docker setup, which is the least consistent part

The repository ships a Dockerfile and a docker-compose.yml, and they are worth reading because the compose file does not quite do what you would expect.

The Dockerfile is straightforward. It starts from node:20-alpine with /app as the working directory, copies package.json and package-lock.json, runs npm install, copies the rest of the source, runs npm run build, exposes port 3000 and finishes with npm start.

So the image is a production build served by next start, which is correct.

The compose file then does something else. It builds from the Dockerfile, maps port 3000, mounts the whole source directory as a volume at /app, sets NODE_ENV to development and runs npm run dev as the command.

That combination means the compose stack runs the development server with your local source mounted over the built image, so the npm run build step inside the image is wasted work and the production image is not what you end up testing. It is a convenient way to get the site up with hot reload in a container, and it is not the way to check the production artefact.

If you want the production behaviour, run the image directly and let it serve with npm start.

The repository also carries a .dockerignore, a SECURITY.md, a CODE_OF_CONDUCT.md and a CHANGELOG.md, and the .github/ directory for the workflows and issue templates.

## The contribution rules, which are strict

The contributing guidelines in the README are unusually prescriptive about issue assignment, and they describe a project with more incoming requests than it can absorb.

There are five numbered sections. On finding and creating issues, you browse the existing issues first, and if you find one that is not already assigned you can assign it to yourself, and if nothing matches your interests you create a new one detailing the problem or improvement.

Assigning issues is where the strictness is. Before starting work on an issue, check that it is not already assigned to someone else, do not work on issues already assigned to another contributor, and your pull request will not be accepted if the issue is already assigned. Assign it to yourself to indicate that you are working on it.

Submitting pull requests has a hard gate: ensure that your PR is linked to an assigned issue, because pull requests without an associated and assigned issue will not be accepted. Beyond that, follow the project's coding standards, and include a clear and concise description of the changes.

Then code review, where you are to be open to feedback and prepared to make changes based on review comments, and to engage in discussions on the PR to clarify questions or concerns.

Finally, testing and documentation: ensure changes are well tested and do not break existing functionality, and update the documentation if the changes affect any part of it.

The rule worth noting is the assignment one. It means the first thing a contributor does is not write code, and it explains why issues in the tracker are pre-assigned, which otherwise looks like a barrier.

## Where Rustcrab is the wrong choice

Four cases argue against it.

The first is if you are looking for a Rust crate or a Rust tool. This is a TypeScript and Next.js repository with a handbook in it. There is no Rust source to build, no cargo command to run and nothing to depend on from a Rust project.

The second is if you want a structured curriculum with exercises. The repository describes itself as everything you need to learn about Rust, and it does hold a book-compendium directory and a rust-handbook-testimonials.md file, but the README documents the site's features rather than a progression with exercises and solutions. If you want the path from variables to lifetimes with problems to solve, a book with exercises is the tool, and this is closer to a curated index and a reader for it.

The third is if you want the authoritative reference. Rustcrab is a community project curating and presenting material, not the language documentation. The Rust book, the standard library docs and the reference manual are the primary sources, and a community site about them is a second-hand view.

The alternative in the same direction is the official Rust Book, which is free, maintained by the project and complete, with no marketing site in front of it. The difference in approach is that rustcrab curates across several sources, adds a search-friendly handbook and a code highlighter, and gives you a single URL to share, while the official material is authoritative, unmaintained by any third party and does not need a star counter to justify itself. If your goal is reading the language well, the official book is the better source and rustcrab is the better bookmark.

## Conclusion

Rustcrab fits a learner who wants a single free place to work through Rust and a site to look at while doing it, since the handbook content and the landing page live in the same repository. It does not fit anyone looking for a Rust crate or a build tool, because there is none here, and it does not fit a production deployment of the site without checking the Docker setup. Clone the repository, run `npm install` and `npm run dev`, and note that the README documents a Node.js 14.x or later prerequisite while the Dockerfile is on node:20-alpine, so use a current Node.

## FAQ

### What is Rustcrab?

It is an open source project with everything you need to learn about Rust, published at rustcrab.com. The repository pairs a book-compendium directory of learning material with a Next.js, Tailwind CSS and TypeScript site that shows the GitHub star count in real time and supports light and dark mode.

### How do I run Rustcrab locally?

Clone the repository, run `npm install` or `yarn`, then `npm run dev` and open http://localhost:3000. For a production build run `npm run build`, which the README says generates an out directory with the optimized build.

### What does the Rustcrab site include besides the handbook?

A real-time display of the repository's GitHub star count, light and dark mode toggling, responsive layout built with Tailwind CSS, links to daily.dev and the GitHub repository, social links to Twitter, LinkedIn, YouTube, Discord and Instagram, and Google Analytics integration.

### Can I contribute to Rustcrab?

Yes, under strict conditions. Your pull request must be linked to an assigned issue, and a PR whose issue is already assigned to another contributor will not be accepted. You assign an issue to yourself before working on it, follow the coding standards, and update the documentation where the change affects it.

### How do I deploy the Rustcrab site?

The README says you can deploy the Next.js application to platforms such as Vercel, Netlify, or any other hosting provider supporting static site hosting. A Dockerfile on node:20-alpine is included, though the docker-compose.yml runs the development server with a mounted source directory rather than the production build.

## Sources

- [FrancescoXX/rustcrab on GitHub](https://github.com/FrancescoXX/rustcrab)
- [License: MIT](https://github.com/FrancescoXX/rustcrab/blob/main/LICENSE)
- [Project website](https://rustcrab.com)
- [README](https://github.com/FrancescoXX/rustcrab/blob/main/README.md)
- [Releases](https://github.com/FrancescoXX/rustcrab/releases)

---

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