• Requirements
  • Linux-specific requirements
• Development workflow
  • Version updates to Code
  • Patching Code
  • Build
    • Creating a Standalone Release
  • Troubleshooting
    • I see "Forbidden access" when I load code-server in the browser
    • "Can only have one anonymous define call per script"
  • Help
• Test
  • Unit tests
  • Script tests
  • Integration tests
  • End-to-end tests
• Structure
  • Modifications to Code
  • Currently Known Issues

Requirements

The prerequisites for contributing to code-server are almost the same as thoseforVS Code.Here is what is needed:

• node v22.x
• git v2.x or greater
• git-lfs
• npm
  • Used to install JS packages and run scripts
• nfpm
  • Used to build.deb and.rpm packages
• jq
  • Used to build code-server releases
• gnupg
  • All commits must be signed and verified; see GitHub'sManaging commitsignatureverificationor followthis tutorial
• quilt
  • Used to manage patches to Code
• rsync andunzip
  • Used for code-server releases
• bats
  • Used to run script unit tests

Linux-specific requirements

If you're developing code-server on Linux, make sure you have installed orinstall the following dependencies:

These are required by Code. Seetheir Wikifor more information.

Development workflow

1. git clone https://github.com/coder/code-server.git - Clonecode-server
2. git submodule update --init - Clonevscode submodule
3. quilt push -a - Apply patches to thevscode submodule.
4. npm install - Install dependencies
5. npm run watch - Launch code-server localhost:8080. code-server will be livereloaded when changes are made; the browser needs to be refreshed manually.

When pulling down changes that include modifications to the patches you willneed to apply them withquilt. If you pull down changes that update thevscode submodule you will need to rungit submodule update --init andre-apply the patches.

When you make a change that affects people deploying the marketplace pleaseupdate the changelog as part of your PR.

Note that building code-server takes a very, very long time, and loading it inthe browser in development mode also takes a very, very long time.

Display language (Spanish, etc) support only works in a full build; it will notwork in development mode.

Generally we prefer that PRs be squashed intomain but you can rebase or mergeif it is important to keep the individual commits (make sure to clean up thecommits first if you are doing this).

Version updates to Code

1. Remove any patches withquilt pop -a.
2. Update thelib/vscode submodule to the desired upstream version branch.
   1. cd lib/vscode && git checkout release/1.66 && cd ../..
   2. git add lib && git commit -m "chore: update to Code <version>"
3. Apply the patches one at a time (quilt push). If the application succeedsbut the lines changed, update the patch withquilt refresh. If there areconflicts, then force apply withquilt push -f, manually add back therejected code, then runquilt refresh.
4. From the code-serverproject root, runnpm install.
5. Check the Node.js version that's used by Electron (which is shipped with VSCode. If necessary, update our version of Node.js to match.

Patching Code

1. You can go through the patch stack withquilt push andquilt pop.
2. Create a new patch (quilt new {name}.diff) or use an existing patch.
3. Add the file(s) you are patching (quilt add [-P patch] {file}). A filemust be added before you make changes to it.
4. Make your changes. Patches do not need to be independent of each other buteach patch must result in a working code-server without any broken in-betweenstates otherwise they are difficult to test and modify.
5. Add your changes to the patch (quilt refresh)
6. Add a comment in the patch about the reason for the patch and how toreproduce the behavior it fixes or adds. Every patch should have an e2e testas well.

Build

You can build a full production as follows:

This does not keepnode_modules. If you want them to be kept, useKEEP_MODULES=1 npm run release

Run your build:

Then, to build the release package:

On Linux, the currently running distro will become the minimum supportedversion. In our GitHub Actions CI, we use CentOS 8 for maximum compatibility.If you need your builds to support older distros, run the build commandsinside a Docker container with all the build requirements installed.

Creating a Standalone Release

Part of the build process involves creating standalone releases. At the time ofwriting, we do this for the following platforms/architectures:

• Linux amd64 (.tar.gz, .deb, and .rpm)
• Linux arm64 (.tar.gz, .deb, and .rpm)
• Linux arm7l (.tar.gz)
• Linux armhf.deb
• Linux armhf.rpm
• macOS arm64.tar.gz

Currently, these are compiled in CI using thenpm run release:standalonecommand in therelease.yaml workflow. We then upload them to the draft releaseand distribute via GitHub Releases.

Troubleshooting

I see "Forbidden access" when I load code-server in the browser

This means your patches didn't apply correctly. We have a patch to remove theauth from vanilla Code because we use our own.

Try popping off the patches withquilt pop -a and reapplying withquilt push -a.

"Can only have one anonymous define call per script"

Code might be trying to use a dev or prod HTML in the wrong context. You can tryre-running code-server and settingVSCODE_DEV=1.

Help

If you get stuck or need help, you can always start a new GitHub Discussionhere. One of the maintainerswill respond and help you out.

Test

There are four kinds of tests in code-server:

1. Unit tests
2. Script tests
3. Integration tests
4. End-to-end tests

Unit tests

Our unit tests are written in TypeScript and run usingJest, the testing framework].

These live undertest/unit.

We use unit tests for functions and things that can be tested in isolation. Thefile structure is modeled closely after/src so it's easy for people to knowwhere test files should live.

Script tests

Our script tests are written in bash and run usingbats.

These tests live undertest/scripts.

We use these to test anything related to our scripts (most of which live underci).

Integration tests

These are a work in progress. We build code-server and run tests withnpm run test:integration, which ensures that code-server builds work on theirrespective platforms.

Our integration tests look at components that rely on one another. For example,testing the CLI requires us to build and package code-server.

End-to-end tests

The end-to-end (e2e) tests are written in TypeScript and run usingPlaywright.

These live undertest/e2e.

Before the e2e tests run, we runglobalSetup, which eliminates the need to login before each test by preserving the authentication state.

Take a look atcodeServer.test.ts to see how you would use it (seetest.use).

We also have a model where you can create helpers to use within tests. Seemodels/CodeServer.ts for an example.

Structure

code-server essentially serves as an HTTP API for logging in and starting aremote Code process.

The CLI code is insrc/node and the HTTP routes are implementedinsrc/node/routes.

Most of the meaty parts are in the Code portion of the codebase underlib/vscode, which we describe next.

Modifications to Code

Our modifications to Code can be found in thepatches directory.We pull in Code as a submodule pointing to an upstream release branch.

In v1 of code-server, we had Code as a submodule and used a single massive patchthat split the codebase into a front-end and a server. The front-end consistedof the UI code, while the server ran the extensions and exposed an API to thefront-end for file access and all UI needs.

Over time, Microsoft added support to Code to run it on the web. They had madethe front-end open source, but not the server. As such, code-server v2 (andlater) uses the Code front-end and implements the server. We did this by using aGit subtree to fork and modify Code.

Microsoft eventually made the server open source and we were able to reduce ourchanges significantly. Some time later we moved back to a submodule and patches(managed byquilt this time instead of the mega-patch).

As the web portion of Code continues to mature, we'll be able to shrink andpossibly eliminate our patches. In the meantime, upgrading the Code versionrequires us to ensure that our changes are still applied correctly and work asintended. In the future, we'd like to run Code unit tests against our builds toensure that features work as expected.

We haveextension docs on the CI and build system.

If the functionality you're working on does NOT depend on code from Code, pleasemove it out and into code-server.

Currently Known Issues

• Creating custom Code extensions and debugging them doesn't work
• Extension profiling and tips are currently disabled