Enum Template 

pub enum Template {
    Base,
    Recommended,
    High,
    QuvytaDev,
    Slim,
    Custom,
}

A ready-made set of the parts a profile’s image is built with, or the person’s own set of them.

No set decides whether the harness asks for permission: it never does, under any of them, because the container is what keeps the work apart from the machine.

Variants

Base

The harness as it comes: the image holds no part of ours. A file on disk that names no template, or names this one, is read as this.

Recommended

The harness set up the way its makers and QCode recommend, with graphify beside it and the harness’s own recommended plugins: “QCode recommended”. The id is older than the name, and stays, because profiles on disk are written with it.

High

QCode recommended, and every other tool the owner of QCode works with installed beside the harness, with instructions written into the workspace so its agents can reach each other: “QCode extra”. The id high is what the template was called before, and stays, because profiles on disk are written with it. See Addition.

QuvytaDev

QCode extra, and what building the Quvyta ecosystem’s Rust terminal apps inside the container needs: “Quvyta development”. See Addition::Rust and Addition::Chromium.

Slim

opencode with oh-my-opencode-slim, the lighter team of agents, and graphify beside it, on the settings, first-start answers and update switches every QCode set writes: “oh my opencode slim”. It never carries oh-my-openagent. Offered to opencode alone (Template::offered); a definition written by hand for another harness gets graphify.

Custom

The parts the person chose one by one: “Custom”. Its file names what it goes without out of the whole list its harness can have (Template::available).

Only a set no older QCode could build is written under it (Template::written_as), and in a folder of its own that an older QCode does not read.

Implementations

impl Template

pub const ALL: [Self; 6]

Every template a definition file can name, in the order the picker offers them: the four ready-made sets, then Custom. Template::Base is in the list because profiles on disk are written with it, though the picker never offers it.

pub fn offered(harness: HarnessKind) -> Vec<Self>

The rows the template page’s picker offers a profile of harness: the ready-made sets, in order, and Custom last. oh my opencode slim is opencode’s alone, since the team of agents it is for is opencode’s.

pub fn id(self) -> &'static str

How the template is written in definition files.

pub fn carries_high(self) -> bool

Whether the template carries everything QCode extra gives: QCode extra itself, and Quvyta development, which is QCode extra and more. What QCode extra does beyond the image — its instructions written into the workspace — follows from this, not from one name.

A set of the person’s own does not carry them, even when it holds every part QCode extra holds: opencode’s QCode extra and QCode recommended install the same parts, so nothing in a set of parts can say which of the two was meant. It gets what QCode recommended gives.

pub fn parse(id: &str) -> Option<Self>

The template written as id, if there is one.

pub fn plain_files(harness: HarnessKind) -> Vec<ConfigFile>

The harness’s settings and first-start answers from its record, naming no plugin: what the “recommended settings” part writes for a harness whose plugin is off.

pub fn maker_switches( harness: HarnessKind, ) -> &'static [(&'static str, &'static str)]

The variables the “recommended settings” part sets in the image for harness: the maker’s switches for its own update check and usage reports, where the harness offers them as variables rather than as keys of its settings file (those are in the file itself).

An update the harness installs by itself would change the image’s program under the person’s feet, inside a container that is remade from the image anyway; a rebuild is how an update arrives. Every name was read in the harness’s own package: Claude Code 2.1.281 lists all three among the variables it reads; opencode 1.18.32 returns from its update check when OPENCODE_DISABLE_AUTOUPDATE is set; Kimi Code CLI 2.1.1 reads KIMI_DISABLE_TELEMETRY for its usage reports and KIMI_CODE_NO_AUTO_UPDATE for “no check, no background install, no prompt”.

pub fn claude_plugins(self) -> &'static [&'static str]

The Claude Code plugins the template installs, as claude plugin install takes them: the five of CLAUDE_STARTER_PLUGINS under QCode recommended, CLAUDE_EXTRA_PLUGINS under QCode extra, every one of CLAUDE_PLUGINS under Quvyta development, none under base.

pub fn available(harness: HarnessKind) -> Vec<Extra>

Every part a profile of harness can have switched on, in the order the wizard lists them: graphify, the plugins of the harness that has them, the teams of agents opencode has, the Rust toolchain and the browser, and the recommended settings.

This is what the page lists, whatever the picker reads: choosing a ready-made set is a way of switching these on, not a shorter list of them. Which of them an image can really carry is the harness’s business; the system refuses Chromium on its own (crate::base::Os).

pub fn parts(self, harness: HarnessKind) -> Vec<Extra>

The parts this template switches on for a profile of harness, in the order the wizard lists them: the ready-made set the template stands for, or, for Template::Custom, the whole list its harness can have.

A custom profile is a list of its own rather than a set, so what it carries is this minus what its file goes without (crate::profile::Profile::parts is the whole of it). The empty set of “the harness as it comes” is a list of everything switched off, so Template::Base — the id older files were written with — has no parts at all.

pub fn written_as(parts: &[Extra], harness: HarnessKind) -> Self

The template a definition file names for a profile of harness whose parts are exactly parts, which the file’s off-list then narrows down to them.

The harness as it comes, every part off, is Template::Base. Otherwise the first ready-made set, in the picker’s order, that holds every one of parts and differs from them only by parts an older QCode can leave out too (Extra::older_can_leave_out): such a file builds the same image under every QCode that reads it. Only a set that is no ready- made set narrowed down that way is Template::Custom.

Trait Implementations

impl Clone for Template

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Template

impl Debug for Template

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Template

impl PartialEq for Template

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Template