sccache integration

sccache is a compiler caching tool that supports C, C++, Rust, and other languages.

Namespace provides high-performance sccache caching with low network latency between runners and the cache storage. Builds reuse compilation results across runs, reducing build times.

sccache caching is particularly effective for:

• C and C++ projects with long compilation times
• Rust projects where incremental compilation can be slow
• Projects that benefit from sharing compilation artifacts across team members

Getting started

You can produce a ready-to-use configuration using the CLI:

1. Configure cache access and start sccache

nsc cache sccache setup generates short-term credentials from your current nsc login and prints the environment variables needed to configure sccache (e.g. SCCACHE_WEBDAV_ENDPOINT, SCCACHE_WEBDAV_TOKEN) as KEY=value lines. Export them into your shell, then start sccache:

echo "export $(nsc cache sccache setup --cache_name default)"
sccache --start-server

sccache will now use Namespace's remote cache for all subsequent compilations. These credentials are short-lived, which suits CI runners and an authenticated shell.

GitHub Actions Example

In GitHub Actions, append the output of nsc cache sccache setup to $GITHUB_ENV so the credentials are available in every subsequent step. Setting RUSTC_WRAPPER: sccache on the build step makes cargo invoke sccache, which auto-starts a server using the env from $GITHUB_ENV.

jobs:
  build:
    runs-on: namespace-profile-default
    steps:
      - uses: actions/checkout@v4
      - name: Configure sccache # [!code ++:2]
        run: nsc cache sccache setup --cache_name default >> "$GITHUB_ENV"
      - name: Build
        env: # [!code ++:2]
          RUSTC_WRAPPER: sccache
        run: cargo build

Using from your local workstation

You can use the same sccache cache from your workstation when you don't have an ambient nsc login. Since the cache is shared, local builds benefit from artifacts already cached by CI, and vice versa.

1. Create a long-term token

Create a long-term token with access to the cache. The command saves the token to token.json in the current directory:

nsc cache sccache create-token --cache_name default

Token ID:    tok_...
Name:        sccache-default-n525mfg
Expires At:  2026-02-13T12:07:43+01:00

2. Set up sccache with the token

Use the saved token to generate the sccache environment variables:

nsc cache sccache setup --token token.json --cache_name default

3. Start sccache

Export the generated environment variables, then start the sccache server:

export $(nsc cache sccache setup --token token.json --cache_name default)
sccache --start-server

The credentials are bound to your user. If the user is removed from the workspace (or their permissions are reduced), the token becomes invalid. The token can also be revoked ahead of time.

How it works

The sccache caching solution provides remote storage for compilation artifacts, where the hot cache lives as close to the consumer (e.g. your CI job runner) as possible. The cold caching tier is backed by our high-performance artifact storage, which lets sccache retain a large number of cached artifacts.

Access to the sccache cache is granted through short-lived secure credentials.

Usage

Namespace accounts sccache cache usage in two categories:

• Artifact cache storage
• Artifact cache reads

For detailed billing information for each item as well as included amounts in your plans, visit the pricing page.