Developer Mode#

The Bluefin Developer Experience (bluefin-dx) is a dedicated developer image with bundled tools. Unlike traditional Linux systems, the operating system and developer environment are explicitly and purposely separated. This means that tooling is not installed on the host, and is instead containerized, in a virtual machine, or scoped to the user's home directory. It is designed to meet the following use cases:

Bluefin endeavors to ship:

• The world's most powerful cloud native developer environment
• Full virtualization support centered around QEMU/KVM, as well as support for Docker and Incus
• Bluefin GDX variant specifically designed for AI and Machine Learning

The Cloud Native Development Approach#

Bluefin goes "all in" on cloud native development and is used differently than a traditional distribution such as Ubuntu:

• Development is done containers, common container patterns include:
  • Devcontainers with VSCode, Jetbrains, or neovim
  • Podman Desktop for container development with a graphical (GUI) interface. Here's an example of a podman/vscode setup - these extensions are included in Bluefin
  • Podman or Docker command line container management.
• Command line applications are installed using homebrew
• Preconfigured ad-hoc containers for Ubuntu, Fedora, and Wolfi are included. Use whichever distribution you want.

This differs from traditional distributions by making the development process operating system agnostic. There is no equivalent to apt install php on Bluefin; development is done with podman or docker directly via an IDE.

We also believe in easy access to other thriving ecosystems like Python via uv. We throw in the towel on "one Linux system package manager to rule them all" because these ecosystems are giants themselves. Critics will say we ship too many package managers, we say we don't ship package managers, we ship ecosystems that users want. And these modern package managers are designed for a world running on containers because that's actually true. And we want it on our desktops out of the box.

The pattern in bluefin-dx (and aurora-dx) centers around devcontainers. Since devcontainers live in the project's git repository, they can be deployed on any operating system: Linux, macOS, or Windows (via WSL). This facilitates "distributed by default" development and avoids Linux users being "the odd one out" when working with teammates on other operating systems.

Each project includes a declarative environment intended to start the user with a "best practice" cloud-native workflow out of the box. The Ultimate Guide to Dev Containers has a good write-up on the advantages of using devcontainers. This means that the development environment is kept in version control instead of coupled to the host.

Homebrew can also be used to install development tools. However, it is recommended to avoid that and declare the project's dependencies in version control. It's so convenient sometimes, it's okay.

Mise is a tool that allows you to install specific versions of applications for a project, (such as node 20 in one project, and node 21 in another). You can use the mise.toml file in your repository to keep track of what specific tools you require. These can also be installed globally. This can be used similar to devcontainers, but does not require you to switch into a container to use it.

You can always use whatever you want. You do not need to use everything in here in order to be productive -- at the end of the day it's your computer and this is a set of defaults.

Enabling Developer Mode#

Turning on developer mode is a two-step process:

Step 1: Turn it on#

ujust devmode to enable or disable the dx mode, then reboot:

Step 2: Add yourself to the right groups#

Bluefin LTS users: You can skip this step and just reboot.

For other Bluefins:

ujust dx-group - to add your user account to the right groups. Then reboot. This step only needs to be done once.

Like all Universal Blue images, switching is atomic, allowing for clean switching between modes depending on the use case.

Features#

Visual Studio Code with Docker#

Visual Studio Code is included in the image as the default IDE. It comes with the devcontainers extension already installed. It's the recommended developer experience, so start here if you're new to containerized development!

• Dev Containers Documentation - you can skip most of the installation instructions and go directly to the tutorial
• Dev Containers Specification
• Beginner's Series to: Dev Containers - great introductory tutorial from the VS Code YouTube channel

The most current Docker Engine is included by default and is set up to be the default container runtime for VSCode Using docker compose is also a great way to get started in container development and is an option if devcontainers don't fit your style. Note, Docker Desktop is not available, use Podman Desktop for graphical container management.

Using Podman with Dev Containers#

The Dev Containers extension defaults to Docker. To switch it to Podman, add these settings to VS Code:

"dev.containers.dockerComposePath": "podman-compose"
"dev.containers.dockerPath": "podman"
"dev.containers.dockerSocketPath": "/run/user/1000/podman/podman.sock"

Run systemctl --user status podman.socket to confirm the socket path for your user ID. For rootful Podman, use /run/podman/podman.sock.

SELinux troubleshooting: If your devcontainer fails to start with SELinux access errors (check ausearch -m avc -ts recent), run restorecon -R -v $HOME/.local/share. For volume mount errors, run restorecon -R -v /path/to/your/project. As a last resort only, you can disable SELinux labeling for a specific container in .devcontainer/devcontainer.json:

{
  "runArgs": ["--security-opt", "label=disable"]
}

Podman and Podman Desktop#

Podman Desktop is included to provide container management. Check out the Podman Desktop documentation for more information. All the upstream podman tools are included. This is the default system container runtime and is the recommended developer configuration for new users.

Built-in Performance Tooling#

Sysprof is included as a systemwide performance profiler. As well as Brendan Gregg's recommended CLI tools:

• bcc, bpftrace, iproute2, nicstat, numactl, sysprof, sysstat, tiptop, trace-cmd, and util-linux

Thanks to Ubuntu and Canonical for the detailed specification and rationale. The project hopes that the inclusion of performance tools will lead to better upstream software.

Quality of Life Improvements#

• A collection of well-curated monospace fonts
• Just task runner for automation tasks
• fish and zsh available as optional shells

Pet Containers#

Pet containers are available as interactive terminals via distrobox. Manage these via the included DistroShelf application, available via the logomenu in the top left corner of your desktop under "Containers":

Use DistroShelf's interface to create your own pet containers from whichever distribution is on the list:

For CLI warriors you can manage your containers with the Terminal's built-in container support:

The included Terminal includes a host terminal so that you can quickly switch between containers and the host.

• The default terminal is Ptyxis, which includes built in integration of distrobox containers. It is aliased as "Terminal" in the menu. It is mapped to Ctrl-Alt-Enter by default for quick launch
• Podman Desktop - Containers and Kubernetes for application developers
• Pods is also a great way to manage your containers graphically

Other Tooling#

JetBrains#

ujust jetbrains-toolbox will fetch and install the JetBrains Toolbox application, which will manage the installation of the JetBrains set of tools. This application will handle installation, removal, and upgrade of the JetBrains products, and is handled completely in your home directory, independent of the operating system image. We do not recommend using the JetBrains flatpaks.

• Check the JetBrains documentation for integrating those tools with the podman runtime.
• Check out how to setup JetBrains with devcontainers
• Uninstallation instructions

The JetBrains blog also has more information on JetBrains Dev Containers support:

• Using Dev Containers in JetBrains IDEs – Part 1

Neovim#

brew install neovim devcontainer then follow these directions for a devcontainer setup:

• Running Neovim with Devcontainers

Virtualization and Container Runtimes#

• virt-manager and associated tooling (KVM, qemu)

Note: Bluefin LTS users must install the QEMU addon from Bazaar:

or via command line: flatpak install flathub org.virt_manager.virt_manager org.virt_manager.virt_manager.Extension.Qemu

• Incus provides system containers (Not available in Bluefin LTS)

Local Application Development#

GNOME Builder is the recommended application stack for making application.

Kubernetes#

Run ujust bbrew and select k8s-tools to install a common set of tools used by Kubernetes administrators. Or install these individually:

CNCF Tools#

For access to the full suite of Cloud Native Computing Foundation tools, use ujust cncf to browse and install from an extensive collection of 89 CNCF projects including graduated, incubating, and sandbox tools. This includes Argo, Cilium, Envoy, Flux, Istio, Linkerd, Prometheus, and many more.

Fonts#

Run ujust bbrew and select fonts to install the following collection of well-curated Mono fonts. Or install these individually. Check the homebrew website to add more fonts, or use the included Embellish tool.