This repository contains personal container images for Devcontainers, tailored for
AI-assisted .NET/NodeJS software development. It aims to provide a reproducible
& standardized Linux development environments.
The full toolchain (language runtimes, SDKs, CLIs, shell, editor tooling, certificate
trust, etc.) is installed at image build time inside the Dockerfile and shipped
as part of the published image. I deliberately do not rely on the devcontainer
spec's Features mechanism to provision the core
toolchain at container-create time.
This is intentional. Baking the toolchain into the build phase gives us:
- Reproducibility. A tagged image (e.g.
opensuse-tumbleweed:2026.02.12.1) is byte-identical for every developer who pulls it. No drift from upstream Features picking up a new version on a Monday morning. - Fast container startup. No multi-minute per-create install step - the container is ready as soon as it's pulled.
- Single auditable supply chain. Every install command, package version, signing
key, and trust root lives in the
Dockerfilein this repo, is reviewed via PR, and is built, vulnerability-scanned, and auto-patched in CI (see π‘οΈ Security scanning & patching). No opaque per-feature install scripts run on the developer's machine. - Version pinning via the image tag, not via a moving Feature version.
Devcontainer Features remain a perfectly valid escape hatch for project-specific
additions that don't belong in the shared base image (see
Add a devcontainer template to your project).
The core toolchain, however, always comes from the image - for example,
Docker-outside-of-Docker (the docker CLI client plus a bind-mounted host socket) is
baked into every flavor rather than pulled in via the docker-outside-of-docker Feature.
Note
π Every flavor below ships a ready-to-use devcontainer.json template under
its <flavor>/.devcontainer/devcontainer.json. The template wires up the published
image with sensible defaults (non-root developer user, Fish as the default
VS Code terminal, persistent Fish history & XDG cache volumes plus shared
logins/caches volumes (Claude Code, GitHub CLI, Azure CLI, NuGet, npm),
Docker-outside-of-Docker wiring with engine-aware Testcontainers host overrides, a
tuned NODE_OPTIONS heap, and a
curated set of VS Code extensions for .NET, web, and GitHub workflows). It is
intended as a starting point: you can freely extend it with any property from the
devcontainer.json reference -
additional mounts
(bind mounts, named volumes, tmpfs), extra forwardPorts, postCreateCommand
hooks, containerEnv/remoteEnv variables, and so on. If you need a tool that
isn't in the base image, you can also layer on a project-specific
Dev Container Feature - but note that the core
toolchain itself is intentionally baked into the image at build time, not provisioned
via Features (see Toolchains).
You can drop the template straight into a project at .devcontainer/devcontainer.json -
see Add a devcontainer template to your project
and each flavor's own README for the full breakdown.
| Metadata | Value |
|---|---|
| Author | Vasil Kotsev |
| Path | OpenSUSE/Tumbleweed/ |
| Devcontainer template | OpenSUSE/Tumbleweed/.devcontainer/devcontainer.json |
The current image is based on opensuse/tumbleweed:latest and includes:
- Microsoft package repo: configured for
OpenSUSEto install.NETpackages - Sensible defaults & toolchains for
.NETandNode.jsenvironments
- Certificate and
TLStooling:CA certificatesMozilla CA bundleCurlOpenSSLGPG(signing & key management)
- System and privilege tools:
Sudo- Development toolchain (
patterns-devel-base-devel_basis) glibcICU
- Source control and remote access:
GitGitHub CLI(gh)OpenSSHLazygit(terminal UI forGit)Git Credential Manager(git-credential-manager, configured via your own~/.config/git/config- see Git Credential Manager)
- Terminal and shell experience:
Fishshell (w/shell integration)FZF(w/shell completion)Ripgrep(w/shell completion)fd(w/shell completion)zoxide(smartercd)tmux(terminal multiplexer)ncdu(disk usage analyzer)
- Developer
CLIand editors:jqawk(GNUgawk)NeovimSQLitetree-sitter-cli(globalnpminstall)
- File management & archives:
Yazi(terminal file manager)7-Zipfile
- Media & document tools:
FFmpegPopplerPDF tools (poppler-tools)
- Language and platform toolchains:
Python 3.14.NET SDK 10.0Node.js LTS(viaFNM)pnpm(viaCorepack)LuaJIT- .NET global tools:
dotnet-efdotnet-outdated-toolgitversion.toolnuke.globaltoolilspycmdeasydotnetgit-credential-manager
- Cloud and secrets tooling:
Azure CLISOPS
- Container tooling:
Docker (DooD)
- Browser/runtime dependencies:
GNOME Keyring- Browser runtime support libraries (graphics/audio/X11/font stack)
- AI developer tooling:
OpenCode V2(globalnpminstall of@opencode/cli)Anthropic Claude Code CLI(globalnpminstall)
Note: the base image opensuse/tumbleweed:latest may include additional preinstalled OS packages not listed above.
| Metadata | Value |
|---|---|
| Author | Vasil Kotsev |
| Path | OpenSUSE/Leap/ |
| Devcontainer template | OpenSUSE/Leap/.devcontainer/devcontainer.json |
A variant of the image above, based on the stable opensuse/leap:16.0 release
rather than the rolling Tumbleweed base. It provisions the same corporate trust
setup, Microsoft package repo, toolchains, and developer defaults - and ships an
equivalent ready-to-use devcontainer.json template. See OpenSUSE/Leap/README.md
for the full breakdown.
| Metadata | Value |
|---|---|
| Author | Vasil Kotsev |
| Path | Ubuntu/LTS/ |
| Devcontainer template | Ubuntu/LTS/.devcontainer/devcontainer.json |
A Debian-family variant based on ubuntu:26.04, providing the same corporate trust
setup, toolchains, and developer defaults (developer user, Fish shell) as the
images above, and a matching ready-to-use devcontainer.json template. Key distribution
differences: .NET is installed from Ubuntu's own apt feed (Microsoft no longer
publishes .NET to packages.microsoft.com for Ubuntu), the Azure CLI is installed
via Microsoft's maintained installer, and fnm/sops are pulled as release binaries
since they are not packaged in apt. See Ubuntu/LTS/README.md for the full breakdown.
Every flavor installs
Git Credential Manager
(GCM) as a global .NET tool. The images configure nothing themselves - add this to
your own ~/.config/git/config (VS Code copies the host git config into the container
at create time; nothing is bind-mounted):
[credential]
helper =
helper = /home/developer/.dotnet/tools/git-credential-manager
credentialStore = plaintext- The empty
helper =drops any system-level helper. It must live in your file, not/etc/gitconfig, because Git reads system config first and appends global config after. credentialStore = plaintextwrites to~/.gcm/storeat mode0700. GCM has no default store on Linux, so without it credential writes fail; usecacheto store nothing.- The path is the
dotnet tool install -glocation; adjust it if you build with a non-defaultUSERNAME.
The first HTTPS clone or push triggers GCM's sign-in flow. Credentials are not persisted
by default - add a volume for /home/developer/.gcm to keep them across recreations.
The images pre-create that directory so the volume is not seeded root-owned.
Each flavor is published to docker.io/vkotzsev/<image> with the following stable
tags built from main:
| Flavor | Image | Stable tags |
|---|---|---|
| OpenSUSE Tumbleweed | opensuse-tumbleweed |
latest, YYYY.MM.DD.N (dated snapshots) |
| OpenSUSE Leap | opensuse-leap |
latest, 16.0 |
| Ubuntu LTS | ubuntu-lts |
latest, 26.04 |
- Tumbleweed uses date-based (
CalVer) versioning: everymainbuild produces a new, immutableYYYY.MM.DD.Nsnapshot (e.g.2026.02.12.1) and moveslatestto it. - Leap and Ubuntu track a fixed version tag (
16.0/26.04) that is overwritten with the newest content on eachmainbuild, alongsidelatest. - Every build (on any branch) also publishes an immutable tag equal to the full 40-char commit SHA, letting you pin an image to the exact commit it was built from.
- Builds from non-
mainbranches publish pre-release tags instead of the above:beta-<version>-<short-sha>,beta-<branch>-<short-sha>, andbeta-<branch>-latest. - Only the immutable full-SHA tag is published at build time; the stable/beta tags are applied after the CI security gate passes (see π‘οΈ Security scanning & patching).
See each flavor's README for its specific tags.
Every published image is scanned and remediated automatically in CI β releases are gated on the result:
- Scan. Each build is scanned with Trivy, pinned to a fixed version. The full vulnerability scan is uploaded to GitHub's code scanning tab, and a second scan collects fixable OS-package vulnerabilities (the only class that can be patched in place).
- Patch. If fixable OS-package vulnerabilities are found,
Copacetic (
copa) patches the image without a full rebuild β it applies a lightweight layer on top of the existing image via the flavor's package manager (zypper,dnf, orapt) that upgrades exactly the vulnerable packages from the scan report, and pushes the result alongside the original. A record of what was remediated is emitted as an OpenVEX artifact. - Verify & gate. The final image (patched or already-clean) is re-scanned before
release. If fixable
HIGH/CRITICALOS-package vulnerabilities remain (e.g. no fix was published upstream yet), the release tags are not updated and the git release tag is never created β solatestand the version tags always point to an image that passed the gate. - Pin safely. The full-SHA tag always exists and refers to the original build, regardless of the gate outcome, so an exact build can always be referenced even when a release is blocked.
Unfixable vulnerabilities (ignore-unfixed results from the upstream base image) are
tracked in code scanning but never block releases, since they cannot be remediated
here. Tooling/language-level findings (e.g. npm or .NET packages) are likewise
visible but out of scope for copa - the fix is upgrading them in the Dockerfile,
which drives the next build.
To use one of these images in your own repository, copy the relevant flavor's
devcontainer.json template into your project, then authenticate to Docker Hub
so the image can be pulled.
- Visual Studio Code with the
Dev Containers
extension (or the
devcontainerCLI) - A container runtime (
DockerorPodman)
Each flavor ships a ready-to-use devcontainer.json example with sensible defaults
(image reference, non-root developer user, Fish as the default VS Code terminal,
persistent Fish history & XDG cache volumes + shared logins/caches volumes, and a
tuned NODE_OPTIONS heap). Git identity is not mounted - VS Code copies the host git
config into the container at create time.
Treat it as a starting point - extend it with anything from the
devcontainer.json reference,
e.g. additional mounts
(bind mounts, named volumes, tmpfs), extra forwardPorts, postCreateCommand
hooks, or containerEnv/remoteEnv variables. If a project genuinely needs a tool
that isn't in the base image, you can also layer on a project-specific
Dev Container Feature - but the core toolchain
itself is intentionally baked into the image at build time rather than provisioned
via Features (see Toolchains).
Copy the template for the flavor you want into your repository at
.devcontainer/devcontainer.json:
| Flavor | Template | Published image |
|---|---|---|
| OpenSUSE Tumbleweed | OpenSUSE/Tumbleweed/.devcontainer/devcontainer.json |
docker.io/vkotzsev/opensuse-tumbleweed:latest |
| OpenSUSE Leap | OpenSUSE/Leap/.devcontainer/devcontainer.json |
docker.io/vkotzsev/opensuse-leap:latest |
| Ubuntu LTS | Ubuntu/LTS/.devcontainer/devcontainer.json |
docker.io/vkotzsev/ubuntu-lts:latest |
Tip
The templates reference the :latest tag. To pin to a specific version, change the
image tag (e.g. docker.io/vkotzsev/ubuntu-lts:26.04), or pin to an exact commit
with the full-SHA tag (e.g. docker.io/vkotzsev/ubuntu-lts:<40-char-commit-sha>).
- VS Code: open the repository and run Dev Containers: Reopen in Container from the command palette.
- CLI: run
devcontainer up --workspace-folder .from the repository root.
Repos whose integration tests use Testcontainers are supported out of the box: the DooD wiring is Testcontainers' native "sibling containers" pattern, and the resource reaper (Ryuk) stays enabled - it is the crash safety net on shared devboxes, so nothing here ever disables it. The one documented exception is rootless Podman (the Podman Desktop default on Windows 11 + WSL), where the engine's user-namespace mapping keeps the reaper from operating; upstream recommends disabling it there as a per-host decision:
export TESTCONTAINERS_RYUK_DISABLED=true
# or, container-wide for one project, in its devcontainer.json:
# "remoteEnv": { "TESTCONTAINERS_RYUK_DISABLED": "true" }Official docs per client: .NET - Custom configuration
(and Running inside a container for the
sibling-container pattern & host overrides),
Node.js - Configuration &
Supported container runtimes,
Java - Supported Docker Environments.
The flavor READMEs' π³ Docker (outside of Docker)
sections cover the details - socket access and the engine-aware
~/.testcontainers.properties host override for .NET.
You don't have to consume the published image - you can build any flavor locally and
point a project at it. Build from the repo root (the Dockerfiles COPY from
Shared/..., so the build context must be the repository root):
docker buildx build --load --platform linux/amd64 -t ubuntu-lts-devbox:local -f ./Ubuntu/LTS/Dockerfile .Note
On macOS pass --platform linux/amd64 (or linux/arm64 on Apple Silicon); the default
builder otherwise targets the host platform and won't produce a Linux image.
Then either retag to the template's image name (docker.io/vkotzsev/<flavor>:latest) or
copy the flavor's devcontainer.json and set its image to your local tag, and bring it
up with the CLI:
devcontainer up --workspace-folder /path/to/your-project
devcontainer exec --workspace-folder /path/to/your-project -- docker psThe CLI has no stop/down command - tear down the container with Docker directly
(docker ps to find the name, then docker rm -f <container>). Each flavor's README has
the full local-build + CLI walkthrough, including the macOS Docker-outside-of-Docker socket
caveat (see π³ Docker (outside of Docker)
in the flavor READMEs).