freeCodeCamp/freeCodeCamp: What the Repository Actually Contains

What the repository is, and what it is not

The README opens by describing freeCodeCamp.org as a donor-supported 501(c)(3) charity, and states that the community has helped more than 100,000 people get their first developer job. The repository is the code that runs that site, plus the curriculum content itself. The README says plainly: "This code is running live at freeCodeCamp.org." That single sentence sets the boundary. This is not a packaged course you install and study offline; it is the application and the lesson definitions that produce the site learners use.

The distinction matters because most people searching for freeCodeCamp want the learning experience, and the README points them at the hosted platform, the forum, the YouTube channel, the news publication and the Discord server. The repository is for the other audience: people who want to read the challenge definitions, run the stack, or send a patch. The README's Contributing section routes contributors to contribute.freecodecamp.org rather than explaining the workflow inline, so the repository README is a signpost, not a manual.

What it solves is narrower than the brand suggests. If you need to know exactly what a challenge asserts, what the certification structure is, or how the platform composes its lessons, the source is here. If you want a course to follow, the source is the wrong artefact.

The monorepo layout: api, client, curriculum, packages

The top-level entries tell you the architecture before you open a single file. There is api/, client/, curriculum/, packages/, tools/, e2e/ and docker/. The root package.json is private and named @freecodecamp/freecodecamp with version 0.0.1, which is the normal shape for a workspace root that is never published. pnpm-workspace.yaml and pnpm-lock.yaml confirm pnpm workspaces, and turbo.json confirms Turborepo as the task runner.

The build scripts mirror that split. There is build:client, build:curriculum and build:api, each invoking turbo with a filter such as -F=@freecodecamp/client. The generic build runs turbo build across the workspace. That means the client, the API and the curriculum are separate build targets with their own caches, and a failure in one does not necessarily block the others.

The curriculum directory is where the learning resources live, and the licence section calls it out specifically. There is also a generated artefact: the clean:curriculum script removes ./curriculum/generated/curriculum.json, which tells you the curriculum is compiled into a JSON file rather than consumed directly from source at runtime. That generated file is the seam between authoring challenges and serving them.

Two smaller details are worth noting for anyone planning to work here. The root has a .devcontainer/ directory, so a container-based development environment is provided, and a sample.env file, so configuration is expected to come from environment variables with a sample as the starting point. Neither is documented in the README itself.

Running it locally: Node 24, pnpm 10, and the first build

The engines field is the first hard constraint. The root package.json requires node >=24 and pnpm >=10. If your machine is on an older LTS release, the install will not match what the repository declares, and there is no fallback documented in the README.

The README does not contain install steps. The scripts in package.json are the closest thing to a documented entry point, so treat them as the source of truth for commands. A conventional first run looks like this:

pnpm install
pnpm run build
pnpm run develop

The first command installs the workspace, the second runs turbo build across all packages, and the third is referenced by the clean-and-develop script, which chains clean, install and develop in that order. Expect the build to take a while the first time; Turborepo caches subsequent runs, and clean:turbo exists precisely to clear that cache when it goes stale.

If you only want the client bundle, the filtered form is cheaper:

pnpm run build:client

That runs turbo with -F=@freecodecamp/client build, so it builds the client package and its dependencies rather than the whole workspace. The same pattern applies to build:api and build:curriculum.

For curriculum work specifically, the generated JSON is the thing you rebuild. The clean:curriculum script deletes it, and the curriculum package has its own build target. There is also a separate challenge editor: challenge-editor-setup initialises a git submodule at tools/challenge-editor and installs its dependencies, after which challenge-editor runs pnpm dev inside that directory. Note that the challenge editor is a submodule, so a plain clone will not populate it; the setup script exists for that reason.

For a container-based start, the repository ships .devcontainer/ and docker/ directories plus a .dockerignore at the root. The README does not describe either, so if you go that route you are reading the configuration files rather than documentation.

Certifications, exams and the academic honesty clause

The README lists six certifications in the Full-Stack Developer Curriculum: Responsive Web Design, JavaScript, Front-End Development Libraries, Python, Relational Databases, and Back-End Development and APIs. It also lists four language certifications marked Beta: A2 English for Developers, B1 English for Developers, A1 Professional Spanish and A1 Professional Chinese. There is a Foundational C# with Microsoft Certification as well.

The completion mechanics are stated explicitly. For the developer certifications, each involves interactive lessons, workshops, labs, reviews and quizzes, and the learner must complete 5 required projects to qualify for the exam. Passing the exam is what allows claiming the certification. The language certifications work differently: they are organised into modules with warm-ups, lessons, practice exercises, review pages and quizzes, and all quizzes must be completed to qualify for the exam at the end.

The README makes a durability promise: once earned, a certification is permanent and linkable from LinkedIn or a resume, and the link shows a verified certification specific to that person. The one stated exception is the Academic Honesty Policy. The README says that when people are caught unambiguously plagiarising, certifications are revoked and those people are banned. That is a real operational commitment, and it is the only condition in the README under which a certification disappears.

The README also mentions that The Odin Project (freeCodeCamp Remix), Coding Interview Prep, Project Euler and Rosetta Code are included to help with interview preparation. Those are named as additions to the curriculum, not as separate products.

Where the repository is the wrong tool

If your goal is to run a learning platform for your own organisation, this repository is a poor fit and the README does not pretend otherwise. There is no documented path for rebranding, no multi-tenant story, and no instructions for pointing the certifications at your own domain. The homepage it advertises is contribute.freecodecamp.org, a contributor guide, not a deployment guide.

The licence split is the second boundary. The README states that the computer software is licensed under BSD-3-Clause, and separately that the learning resources in the /curriculum directory including their subdirectories are copyright © 2014 freeCodeCamp.org. Those are two different statements about two different parts of the same repository. Anyone planning to reuse the challenge text, lesson copy or project descriptions should read LICENSE.md rather than assuming the permissive software licence covers the content. This is not legal advice; it is a pointer to the file that governs the question.

The third boundary is operational. The README documents no rollback procedure, no supported upgrade path between versions, and no release notes. The version field is 0.0.1 and the package is private, so there is no published artefact to pin against. If you fork this to run a production service, you are maintaining a fork of a fast-moving monorepo without a changelog to diff against.

Finally, the README does not describe offline use. The search interest in running freeCodeCamp offline is real, but nothing in the repository README addresses it, and the platform is described as running live at freeCodeCamp.org. Do not expect the README to answer that question.

How it compares to a self-hosted LMS

The natural alternative for someone evaluating this repository is a general-purpose learning management system such as Moodle or Open edX. The difference in approach is structural. An LMS is built around courses you author and enrol learners into; the content is data you supply. freeCodeCamp's repository is built around a fixed curriculum that ships with the application, compiled into a generated JSON artefact and served by a client and API that were written for that specific content shape.

That inversion has consequences. With an LMS, the hard part is authoring and administering content, and the software is designed to stay out of your way. With this repository, the content is already written and the hard part is running and extending the stack: a pnpm workspace with Turborepo, a Node 24 floor, a submodule for the challenge editor, and a build pipeline that produces curriculum.json. The tooling for authoring exists, but it is aimed at contributors to this curriculum, not at instructors writing their own.

A second alternative is simply using the hosted site. For a learner, that is the intended path and the README says so. Cloning the repository to study adds nothing except the ability to read challenge definitions directly, which is occasionally useful when a test failure is ambiguous but is not a substitute for the platform.

The honest comparison is therefore not feature-by-feature. It is a question of whether you want software that adapts to your content, or content that ships with its software. This repository is firmly the second.

Maintenance, licence and what to check before you commit

The repository is not archived. No last push date is given, so there is no basis for a statement about how recently the code moved, and none should be inferred from the presence of a renovate.json file, which only indicates that dependency updates are automated in configuration.

Upgrade cost is the practical concern. The engines field pins Node >=24 and pnpm >=10, and no releases are listed, so upgrades arrive as commits on main rather than as versioned artefacts. A fork has to track those commits manually. The clean-and-develop script exists for the case where caches and dependencies have drifted, and clean:turbo plus clean:packages give you the two levels of reset: Turborepo caches first, then all node_modules directories.

On licensing, the split described above is the thing to verify. BSD-3-Clause on the software permits reuse under its terms, but the curriculum directory carries its own copyright notice. If your use case involves redistributing lesson content rather than running the application, read LICENSE.md before you plan anything, and treat the README's two sentences as a signpost rather than a full statement of terms.

The concrete things to check first are therefore: your Node and pnpm versions against the engines field, whether the Docker configuration in docker/ matches your deployment target, whether the challenge editor submodule is something you need (it requires the separate setup script), and how the curriculum build produces curriculum.json in your environment.

Editorial conclusion

Adopt this repository if you want to run, audit or contribute to the platform behind freeCodeCamp.org, or if you need the curriculum source under /curriculum for your own tooling. Do not adopt it if you want a self-hosted LMS for your own courses: there is no documented path to rebrand or repoint the certifications, and the learning resources carry a separate copyright notice. Before committing, verify that your Node and pnpm versions satisfy the engines field, check whether the Docker route in /docker fits your environment, and read the LICENSE.md split between the BSD-3-Clause software and the curriculum directory.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository