# exercism/javascript is a course disguised as a repository

> The Exercism JavaScript track is the exercise set, test suites and tooling behind one of Exercism's learning tracks, with concept exercises that teach the syllabus and practice exercises that open as you progress. It currently does not accept community contributions, which changes what the repository is for.

**exercism/javascript** — Exercism exercises in JavaScript.

- Repository: https://github.com/exercism/javascript
- Website: https://exercism.org/tracks/javascript
- Stars: 653 · Forks: 663
- Language: JavaScript
- License: MIT
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/exercism-javascript

## A track is a syllabus plus a set of graded exercises

The repository is described as the JavaScript track, one of the many tracks on Exercism, holding all the exercises that are currently implemented and available for students to complete. The important word there is students. This is not a library and not a framework. It is the content of a course, stored as files in a repository, and the repository layout reflects that. The top level contains a concepts/ directory and an exercises/ directory, plus config.json, which is where the track definition lives, along with a reference/ directory, a config/ directory, scripts/, docs/, a bin/ directory and the usual project furniture such as babel.config.js, jest.config.js and eslint.config.mjs. The track consists of concept exercises that teach the JavaScript syllabus and practice exercises, which open as you progress through the syllabus and can be used to practise concepts learned. The audience of the repository itself is different from the audience of the track. Learners interact with Exercism, not with this repository, but anyone who wants to know exactly what a track expects of a solution reads these files.

## Contributions are paused and the repository says so plainly

The most consequential fact in the repository is an important notice at the top of the project readme, and it deserves to shape any plan you make around this project. The project states that it values its community but that this repository does not accept community contributions at this time, and that there are no active maintainers to review pull requests, and it links to a community blog post about freeing maintainers for details. The repository topics carry the same signal, with community-contributions-paused and maintained among them. That combination is worth reading carefully rather than skimming. The track is not abandoned: the last push was on 2026-10-18, the repository is not archived, and the tooling and exercise set are current. What has changed is who may change them. A fork is the realistic route for anyone who needs to alter an exercise, and a pull request to this repository will not be reviewed. The related repositories list in the project notes matters for the same reason, since the JavaScript Analyzer, Representer, Test Runner and Static Analysis Shared Library are separate projects, and the TypeScript track and its tooling share improvements with the JavaScript ones in both directions.

## The test runner is jest, but not the way you would call jest

The tooling is where the engineering is, and the test setup is the part that surprises people. The project documentation says running the test suite runs jest tests for all sample solutions, and then explains why it is not the regular way to run jest: the example solution files must be renamed to be imported correctly into the test files. That is why the workflow goes through a script rather than straight to the test runner. The command is:

```bash
corepack pnpm node scripts/test.mjs
```

And it is scoped if you need it to be. If the ASSIGNMENT environment variable is set, only that exercise is tested, and the example given is testing the example.js for the practice exercise two-fer:

```bash
ASSIGNMENT=practice/two-fer corepack pnpm node scripts/test.mjs
```

There is a wrinkle for Windows, where environment variables are set differently depending on the shell. The project suggests cross-env to normalise this, with two forms depending on whether it is installed globally or run through the package runner. The dependency list backs the tooling up, with jest at version 30, babel-jest and an Exercism babel preset, expect and the jest globals, shelljs for the scripts, diff, prettier, eslint and the Exercism eslint config. The package manifest also pins pnpm at 9.15.2 as the package manager and calls for every script to go through corepack, so the tooling assumes a consistent local install rather than whatever happens to be global on your machine.

## Lint rules are stricter for maintainers than for students

The linter runs eslint for all files that require linting, through another script rather than a bare eslint call:

```bash
corepack pnpm node scripts/lint.mjs --fix
```

The interesting decision is who the rules are for. The project states that the lint rules imposed on contributors and maintainers are stricter than those for the student, and explains the idea: style rules are not imposed on students, but potential errors are guarded against. The file list makes the split concrete. Files with strict rules are the per-exercise spec files named slug.spec.js, the CI proof file .meta/proof.ci.js and the exemplar file .meta/exemplar.js. Files with loose rules are custom.spec.js and the per-exercise slug.js files. That is a coherent policy for a learning platform. A learner's solution should not be rejected for a formatting preference, but a test file or an exemplar, which are the parts other learners depend on, should meet a higher bar. The manifest adds lint, test, watch and format scripts on top of the scripted entry points, and there is a separate .prettierrc and .prettierignore for formatting, with a .editorconfig, an .npmrc and a pnpm-lock.yaml.

## How an exercise is actually built

The file names give you the anatomy of a single exercise without opening one. A practice exercise under exercises/ carries a slug.js stub for the student and a slug.spec.js test file, and the same exercise in the reference/ directory holds the exemplar solution that the tests are known to pass against. The .meta directory holds metadata, with proof.ci.js used to check the proof and exemplar.js holding the reference implementation. config.json at the root is the track definition, and the config/ directory holds configuration for the tooling, while docs/ holds documentation and TAGS.md tracks the tags applied across the track. The .appends/ directory and the bin/ directory with its fetch-configlet script handle tooling concerns such as obtaining configlet, the tool Exercism uses to validate track structure. The exercises/ and concepts/ directories are where the content lives, and the concepts/ directory mirrors the syllabus structure referenced from the track page. The testSequencer.js file at the root sits alongside jest.config.js, which is consistent with a custom test ordering. The project points to CONTRIBUTING.md as the place listing the requirements for contributing to the track, and also as the place describing the test tool among the tools available.

## What this repository is for, and what it is not

The limitation here is not technical, it is a boundary on use. This is content and tooling for a specific course, not a JavaScript learning framework you can point your own curriculum at, and it is not a place to send a pull request at the moment. If you want to learn JavaScript through Exercism, the track page is the product and it works as described. If you want to understand what a good Exercism solution looks like for a given exercise, the reference/ directory and the spec files are the answer, and the spec files are especially useful because they are the exact contract. If you are building your own exercise track, the tooling here is a working example, but the pieces are spread across separate repositories for the analyzer, the representer and the test runner, and the project notes that improvements flow both ways between the JavaScript and TypeScript tracks. The last point is about expectations. The last push was on 2026-10-18 and the repository is not archived, so the exercises and tooling continue to be worked on even though contributions are paused. Read the two facts together rather than choosing one of them.

## Conclusion

Use this repository as the reference for what the Exercism JavaScript track asks a learner to write, and as a worked example of how an exercise track separates concept teaching from practice. Do not expect to contribute to it now, because the project states the repository does not accept community contributions and that there are no active maintainers to review pull requests. Before you plan anything on it, read the freeing maintainers blog post the repository links to, and if you want to contribute to Exercism work generally, look at whether another track is currently accepting contributions instead.

## FAQ

### What is the Exercism JavaScript track repository?

It holds the exercises currently implemented and available for students to complete on the JavaScript track, split into concept exercises that teach the syllabus and practice exercises that open as you progress. The track definition lives in config.json, and the exercises live in the exercises/ and concepts/ directories.

### Can I contribute to the Exercism JavaScript track?

Not at the moment. The repository states that it does not accept community contributions at this time because there are no active maintainers to review pull requests, and it links to a community blog post about freeing maintainers for the details.

### How do I run the test suite for the Exercism JavaScript track?

Use `corepack pnpm node scripts/test.mjs`, which runs jest over all sample solutions. It does not call jest directly because the example solution files have to be renamed to be imported correctly into the test files. Setting the ASSIGNMENT environment variable restricts the run to a single exercise, for example `ASSIGNMENT=practice/two-fer corepack pnpm node scripts/test.mjs`.

### How do I run the linter for the Exercism JavaScript track?

Run `corepack pnpm node scripts/lint.mjs --fix`, which runs eslint over the files that require linting. The rules are stricter for contributors and maintainers than for students, with strict rules on the spec files, .meta/proof.ci.js and .meta/exemplar.js, and loose rules on custom.spec.js and the exercise stub files.

### What license is the Exercism JavaScript track released under?

The package manifest and the licence file at the root of the repository both state the MIT licence, and the track is published as a private package under the name @exercism/javascript.

## Sources

- [exercism/javascript on GitHub](https://github.com/exercism/javascript)
- [Issues](https://github.com/exercism/javascript/issues)
- [License: MIT](https://github.com/exercism/javascript/blob/main/LICENSE)
- [Project website](https://exercism.org/tracks/javascript)
- [README](https://github.com/exercism/javascript/blob/main/README.md)

---

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