Skip to content
Spinbox is experimental: APIs change and data may be lost. Status lists what is built and what proves it.

Status

View Markdown

Every row of this page is a line of internal/features in spin, and a test there resolves it against the tree. A row that says built names what shows the feature exists - a procedure the control plane serves, a command the CLI has, or a test - and, under End to end, the tests that drive a real runner and its guest and check what the feature did, or what no test checks yet. spin’s build checks that each of those tests is there and not quarantined; whether it checks the whole feature is its review’s. A row that says not built is an item of docs/ROADMAP.md. The page is written by task reference from spin features at spin 51f7e0dea, and cannot say a feature the binary does not. spin is a private repository: a link to its code opens only for someone with access to it.

FeatureExistsEnd to end
A machine per workspace: KVM, its own kernel, root, a persistent disk, SSHTestAWorkspaceBootsARealGuest, a test of internal/e2eTestAWorkspaceBootsARealGuest
Create, start, stop and deleteWorkspaceService/CreateWorkspaceTestE2E_WorkspaceCRUD
A trash: a deleted workspace stays whole, for its owner to undelete, until its days are upTestAWorkspaceWhoseDaysInTheTrashAreUpIsErasedFromItsHost, a test of internal/e2eTestATrashedWorkspaceIsWholeWhenItsOwnerUndeletesIt
TestAWorkspaceWhoseDaysInTheTrashAreUpIsErasedFromItsHost
Idle suspend, with a question before it that a keep answersTestAWorkspaceNobodyUsesIsSuspendedUnlessKeptOrHeld, a test of internal/e2eTestAWorkspaceNobodyUsesIsSuspendedUnlessKeptOrHeld
A workspace that ran as long as the installation allows is suspendedTestAWorkspaceThatRanForAsLongAsAllowedIsSuspended, a test of internal/e2eTestAWorkspaceThatRanForAsLongAsAllowedIsSuspended
A process inside holds its workspace awake while it livesTestAWorkspaceNobodyUsesIsSuspendedUnlessKeptOrHeld, a test of internal/e2eTestAWorkspaceNobodyUsesIsSuspendedUnlessKeptOrHeld
Suspend with the processes where they are; a start resumes themTestAWorkspaceNobodyUsesIsSuspendedUnlessKeptOrHeld, a test of internal/e2eTestE2E_ASuspendedWorkspaceResumesWhereItWas
TestAWorkspaceNobodyUsesIsSuspendedUnlessKeptOrHeld
Cores and memory lent while the host has them, and taken back
A loan refused while the host is full has no test against the stack: the budget is the host’s own cores and half its memory, which no lane’s workspaces fill.
TestABusyWorkspaceIsLentCoresAndGivesThemBack, a test of internal/e2eTestABusyWorkspaceIsLentCoresAndGivesThemBack
TestABusyWorkspaceIsLentMemoryAndGivesItBack
TestAnEditorAtTheFloorIsNotKilledForMemory
A grant of cores and memory of its own, for a whileTestAGrantWhoseTimeIsUpIsGivenBackToTheMachine, a test of internal/e2eTestAGrantWhoseTimeIsUpIsGivenBackToTheMachine
TestAResumedWorkspaceIsGivenWhatItIsGrantedWhileItRuns
An administrator changes a running workspace’s bandwidth, its connections openTestAnAdministratorChangesARunningWorkspacesBandwidth, a test of internal/e2eTestAnAdministratorChangesARunningWorkspacesBandwidth
TestAWorkspacesBandwidthHoldsAcrossItsRunsAndItsRunner
Move a running workspace to another host, its processes as they areTestHostsAMoveTakesARunningWorkspaceToAnotherHost, a test of internal/e2eTestHostsAMoveTakesARunningWorkspaceToAnotherHost
Clone a workspace: its disk, team, project, size, policies and environment, in oneTestACloneHoldsWhatItsSourceWroteAndItsShape, a test of internal/e2eTestACloneHoldsWhatItsSourceWroteAndItsShape
Recover a workspace whose host is gone, at a cost its owner acceptsTestHostsAWorkspaceWhoseHostIsGoneIsRecoveredOnAnother, a test of internal/e2eTestHostsAWorkspaceWhoseHostIsGoneIsRecoveredOnAnother
A workspace outlives its runnerTestAWorkspaceOutlivesItsRunner, a test of internal/e2eTestAWorkspaceOutlivesItsRunner
Quarantine, by an administratorWorkspaceService/QuarantineWorkspaceTestE2E_AQuarantinedWorkspaceIsHeldUntilReleased
Why a workspace is not behaving: status, console, historyspin workspace statusTestE2E_AQuarantinedWorkspaceIsHeldUntilReleased
TestE2E_AWorkspacesConsoleIsWhatItsMachinePrinted
The owner’s shell, environment, editor settings, Taskfile and dotfiles reach the guest as they save themTestAWorkspacesOwnEnvironmentIsInItsOwnersLoginShell, a test of internal/e2eTestTheOwnersSettingsArriveInTheGuest
TestAWorkspacesOwnEnvironmentIsInItsOwnersLoginShell
Reset a disk to what it was created fromspin workspace resetTestE2E_ResetPutsAWorkspaceBackToWhatItWasCreatedFrom
Claude Code, Codex and T3 Code on every workspace’s PATH, at the versions the release pins, with their own defaults
Where an administrator accepted their terms (Admin → Extensions) or an operator publishes them: no image carries Claude Code, which only Anthropic may distribute.
TestTheAgentCLIsAreOnPathWithThePinnedVersions, a test of internal/e2eTestTheAgentCLIsAreOnPathWithThePinnedVersions
An agent UI: T3 Code in a workspace as its agent user, over the owner’s SSH session - from spin agent on the person’s computer, or in the workspace’s Agent tab in the dashboard, which frames the client and carries it over a passkey’s session
The lane has no provider credential, so no test has a model answer through the brokered egress: the server is reached, as the agent’s user, and nothing is asked of it. The browser’s test drives the page with a virtual authenticator, which no real passkey’s maker vouches for.
spin agent --portTestTheSupervisorRunsTheAgentForItsOwner
TestE2E_TheAgentIsServedOnThisComputerWhileTheSessionIsOpen
agent.spec.ts: a passkey signs the person in, and the agent runs in their workspace from the dashboard
Claude Code and Codex signed in from the agent’s page: each CLI’s own login, run by the supervisor as the agent’s user, its credentials kept in the agent’s home and never passing through the page
The lane has no provider account: it begins a login and sees the provider’s page, and finishing one is the unit tests’ on each CLI’s own output.
AgentService/BeginLoginTestTheSupervisorRunsTheAgentForItsOwner
A person signs Claude Code and Codex in once: every workspace of theirs, plain or a project’s, is handed the same credentials and hands back each refresh and logout, and a workspace that names a guest holds none
The lane has no provider account: its login is the file the CLI writes, written as the agent’s user. Only a workspace its owner’s alone through all it came from holds them: a project opened from its prebuild does, but not a prebuild’s build, a copy of another person’s snapshot, or one made before the release that keeps the mark.
TestAPersonSignsInToTheAgentOnceForEveryWorkspaceOfTheirs, a test of internal/e2eTestAPersonSignsInToTheAgentOnceForEveryWorkspaceOfTheirs
The supervisor runs the agent for its owner while it is used: started, paired and listed over the owner’s own session on a socket only root opens, and stopped once nobody has used it for half an hour and no chat is at work
That it stops once idle is the sweep’s unit test on a clock the test moves: no lane waits half an hour.
AgentService/StartTestTheSupervisorRunsTheAgentForItsOwner
The agent’s chats listed on the workspace - titles, paths and times, never a message - reported by its supervisorWorkspaceService/ListAgentThreadsTestTheAgentsThreadsAreListed
Chat mode: the dashboard flips to the person’s own chats across their workspaces, grouped by project, with the agent full height and a new chat that makes its workspaceWorkspaceService/ListOwnAgentThreadsnot yet: The RPC is held to the caller’s own chats by its unit test, the mode by the dashboard’s; no lane opens chat mode in a browser against an agent that has reported.
The agent’s home is a volume of its own: the chats and sessions outlive the workspace, kept in the installation’s store as every disk is, and a new workspace mounts them at its creation
Sealed with the workspace’s checkpoints, claimed with the launch beside the disk, and moved with the workspace.
spin workspace create --agent-homeTestAnAgentsHomeOutlivesItsWorkspace
FeatureExistsEnd to end
Open a repository, branch, commit or pull request from its URL, in the dashboard (/launch) and from the terminal
From the terminal; the dashboard’s /launch page makes the same create and has no test of its own against the stack.
spin open --no-connectTestE2E_AURLOpensTheWorkspaceItNames
A workspace opened at a commit or a pull request, checked out as pr-<n>TestAProjectsWorkspaceOpensAtTheCommitItWasAskedFor, a test of internal/e2eTestAProjectsWorkspaceOpensAtTheCommitItWasAskedFor
TestE2E_AURLOpensTheWorkspaceItNames
Teams, with owner, admin and memberspin team member roleTestE2E_ATeamRoleIsWhatItsHolderMayDo
A team’s own identity providersTeamService/CreateIdentityProviderTestE2E_ATeamsIdentityProviderIsItsAdminsAndSignsNobodyIn
Your GitHub account, connected once: private repositories cloned and pushed with nothing on the diskForgeService/CompleteConnectnot yet: consent takes a person on GitHub’s page, and revoking a grant would end the one authorization a lane could live on: checked by hand once per release
Your GitHub account connected from the CLI, with a code entered on GitHub’s pagespin git connectnot yet: the code is entered by a person on GitHub’s page: checked by hand once per release
A repository picked from the ones your account reachesspin git reposnot yet: a real GitHub account the lane can search with
A team’s own network policies, where the installation allows themspin team policy setTestATeamsOwnPolicyIsWhatItsWorkspacesReach
Projects of the installation: a repository and the shape of the workspace that opens it, shared with everyone or someTestAProjectsWorkspaceHasItsRepositoryCheckedOutAtTheRef, a test of internal/e2eTestAProjectsWorkspaceHasItsRepositoryCheckedOutAtTheRef
Prebuilds of a project’s refs, as the floor of the workspaces that open themTestAProjectOpensAsItsPrebuildMadeIt, a test of internal/e2eTestAProjectOpensAsItsPrebuildMadeIt
A team’s workspaces run on the installation’s hostsTestATeamsWorkspaceRunsOnTheInstallationsHost, a test of internal/e2eTestATeamsWorkspaceRunsOnTheInstallationsHost
FeatureExistsEnd to end
Snapshots of a running workspace’s diskWorkspaceService/CreateSnapshotTestACloneHoldsWhatItsSourceWroteAndItsShape
TestADiskSnapshottedPastTheThresholdIsCompactedWhileItRuns
Snapshots with memory, resumed with their processesTestARunningWorkspaceResumesFromASnapshotsMemory, a test of internal/e2eTestARunningWorkspaceResumesFromASnapshotsMemory
Restore a workspace to a snapshotTestARestoredWorkspaceBootsOnTheSnapshotItWasRestoredTo, a test of internal/e2eTestARestoredWorkspaceBootsOnTheSnapshotItWasRestoredTo
TestE2E_TheQuickstartsDiffIsWhatTheSiteShows
A diff of the files that changed between two snapshotsTestADiffOfTwoSnapshotsIsWhatChangedBetweenThem, a test of internal/e2eTestADiffOfTwoSnapshotsNamesWhatWasAddedChangedAndRemoved
TestE2E_TheQuickstartsDiffIsWhatTheSiteShows
Share a snapshot with a person or make it public, and create a workspace from itTestACloneOfASnapshotRegistersAsItself, a test of internal/e2eTestASharedSnapshotIsCreatedFromByThePersonItIsSharedWith
What looks like a credential is found before a share, and the share refused unless acknowledgedShareService/ShareSnapshotTestE2E_ASharedSnapshotIsScannedForCredentials
A long chain is compacted while the workspace runsTestADiskSnapshottedPastTheThresholdIsCompactedWhileItRuns, a test of internal/e2eTestADiskSnapshottedPastTheThresholdIsCompactedWhileItRuns
FeatureExistsEnd to end
Egress is closed by default; policies, by tag, name what a workspace may reachTestAnOwnerMayOnlyChooseAPolicyTheInstallationDeclares, a test of internal/e2eTestAWorkspaceNamedNoPolicyReachesNothing
TestChangingAWorkspacesPoliciesReachesTheHostThatRunsIt
A workspace’s DNS goes upstream only for what its policy names, so a policy that closes egress closes the tunnel through namesTestAWorkspaceAsksItsResolverOnlyWhatItsPolicyNames, a test of internal/e2eTestAWorkspaceAsksItsResolverOnlyWhatItsPolicyNames
A policy changed reaches the host that runs the workspaceTestChangingAWorkspacesPoliciesReachesTheHostThatRunsIt, a test of internal/e2eTestAnEditedPolicyChangesWhatARunningGuestReaches
TestChangingAWorkspacesPoliciesReachesTheHostThatRunsIt
Brokered names: the host’s proxy stands in and adds what the workspace never holds - a team secret, a forge token, its identity, a cloud role
The team secret’s value is read at the origin; the forge token, identity and cloud role injections have no test against the stack.
spin team secret setTestAPersonsRuleAndAnAgentsOnOneNameEachArriveWithTheirOwnInjection
What a workspace reached, what it looked up and what it was refusedspin workspace egressTestE2E_EgressIsAnsweredByTheHostTheWorkspaceRunsOn
Each request to a brokered name as the proxy read it, served or refused and why; and whether each injection’s secret is the team’s to giveTestABrokeredRequestIsSeenAsTheProxyReadIt, a test of internal/e2eTestABrokeredRequestIsSeenAsTheProxyReadIt
The egress proxy is a process of its own, holding no key of the host’s, started again by the runner when it endsTestTheEgressProxyIsAProcessOfItsOwnThatTheRunnerStartsAgain, a test of internal/e2eTestTheEgressProxyIsAProcessOfItsOwnThatTheRunnerStartsAgain
A brokered rule names whose it is, the agent’s or the person’s: one policy says what each may reach and with whatTestABrokeredNameForTheAgentIsTheAgentsAlone, a test of internal/e2eTestAPersonsRuleAndAnAgentsOnOneNameEachArriveWithTheirOwnInjection
TestABrokeredNameForTheAgentIsTheAgentsAlone
A WebSocket to a brokered name: its handshake under the rule’s headers and scope, then bytes each way
The rule’s header on the handshake is not read at the origin: the lane’s WebSocket echo answers frames, not headers.
TestAWebSocketToABrokeredNameIsCarriedAfterItsHandshake, a test of internal/e2eTestAWebSocketToABrokeredNameCarriesTheGuestsBytesAndRefusesAPathOutOfScope
TestAWebSocketToABrokeredNameIsCarriedAfterItsHandshake
HTTP/2 to a brokered name, the proxy’s ALPN the real host’s: a rule’s headers set stream by stream, gRPC’s trailers both ways
gRPC’s trailers are egressproxy’s h2 test against an origin of its own; the lane has no gRPC origin to reach.
TestHTTP2ToABrokeredNameIsTheRealHosts, a test of internal/e2eTestHTTP2ToABrokeredNameIsTheRealHosts
TestEachStreamOfAnHTTP2ConnectionToABrokeredNameCarriesTheRulesHeader
Watch where a workspace connects, into its logsspin workspace watchTestE2E_AWatchedWorkspacesConnectionsAreInItsLogs
An agent the supervisor starts is marked, and reaches only brokered namesTestARealWorkspaceMarksTheAgentItsSupervisorStarts, a test of internal/e2eTestAnAgentReachesOnlyBrokeredNames
TestARealWorkspaceMarksTheAgentItsSupervisorStarts
Published ports at https://{port}-{workspace}.{domain}: private, whitelisted or publicspin port exposeTestAPublicPortIsReachedWithNoSessionAtAll
workspace-sign-in.spec.ts: a visitor signed in to the dashboard reaches their private port
FeatureExistsEnd to end
Sign in with GitHub or an OIDC providerAuthService/StartLoginnot yet: a GitHub provider: the sign-in through it and the verified email it gives
Device login for a terminalAuthService/StartDeviceLoginTestE2E_Logout
auth.spec.ts: the CLI’s device page stands alone and keeps its code through a sign-in
API keys for scripts and agentsspin api-key createTestE2E_APIKeyCRUD
SSH keys, and plain ssh to spin.<workspace>spin ssh-configTestE2E_SSHConfigCarriesSSHToAWorkspace
A key logs in only once its person adds it with a passkey: their own for good, a browser’s for twelve hoursPasskeyService/BeginPasskeyCeremonyTestOnlyTheOwnerAndTheirGuestsLogInToAWorkspace
Guests of a workspace, let in by its owner with a passkeyspin workspace guestsTestOnlyTheOwnerAndTheirGuestsLogInToAWorkspace
A workspace’s identity, signed by its host, for the audiences its installation allowsTestAWorkspacesIdentityIsTheHostsSignatureOfItsSet, a test of internal/e2eTestAWorkspacesIdentityIsTheHostsSignatureOfItsSet
VS Code over SSH, with the server the installation publishes and nothing downloaded
The server is Microsoft’s, for Remote-SSH; spin code also opens an editor with Open Remote - SSH, which downloads its own. spin code itself is run by its unit tests only: it opens a desktop editor, which no lane has.
TestAVSCodeServerOfAnotherCommitIsHandedToTheRunningMachine, a test of internal/e2eTestTheCarriedVSCodeServerRunsOfflineAndAnswersOverTheSSHTunnel
TestAVSCodeServerOfAnotherCommitIsHandedToTheRunningMachine
Run a command in a workspace, copy files to and from itspin execTestE2E_ADetachedRunIsFollowedToItsEndAndFilesGoBothWays
A program runs a command and reads and writes files in a workspace through the API, with a key that holds workspace:exec, every call recorded with the key it came onExecService/ExecTestAKeyWithExecRunsACommandInAWorkspaceAndOneWithoutIsRefused
An agent works in workspaces through spin mcp on a key delegated to it: never more than the key it came from - scopes, team, projects, end, how many workspaces and cores its tree holds - and revoked with itspin mcpTestE2E_AnAgentDrivesAWorkspaceThroughMCPOnADelegatedKey
An agent in a workspace drives others with spin, on a key it gets for the workspace’s own SPIFFE identity - a child of the key that made the workspace, through its host, whatever the workspace’s network
No forge in the lane: a workspace reaches no private or host address, and no test repository has a credential in CI yet, so an agent opening a pull request is not run.
AuthService/ExchangeWorkloadTokenTestAnAgentInAWorkspaceDrivesAnotherOnTheIdentityOfItsWorkspace
FeatureExistsEnd to end
Installation settings seeded from a file; a change in the file is a proposal to apply or dismissAdminService/DecideConfigChangeTestTheInstallationFileSeedsAndItsChangesAreAnAdministratorsToDecide
Every installation setting read and changed from the terminal, by the definitions the dashboard and the file usespin admin settings setnot yet: the RPC’s round trip of every definition is tested against a real database; no lane runs the command against a stack yet
Resource presetsAdminService/CreateResourcePresetadmin.spec.ts: an admin’s preset sizes a person’s workspace, and is gone once deleted
Registration: open, by allowlist, or closedAdminService/SetSettingsadmin.spec.ts: closed, open and a domain on the allowlist decide who registers
admin.spec.ts: the allowlist lets in who it names, and nobody else
An audit logAdminService/ListAuditLogTestE2E_AnAdministratorsActionIsAuditedWithItsActorAndTarget
admin.spec.ts: admin reads the log and can narrow it to one kind of event
A timeline: what happened to a workspace, a runner, a team, a project or the installation, by whom, in one readAdminService/ListTimelinenot yet: no lane reads it yet: its reading is held against a real database by internal/controlplane/domain/timeline’s tests, and a host’s loss and return by hostserver’s over a real stream
The control plane’s jobs, and running one nowspin admin jobsTestE2E_Admin
admin.spec.ts: admin runs a job by hand and sees how it ended
The month’s bill, its forecast, and what each workspace costspin admin costsnot yet: the cloud’s real bill read: no lane has an AWS account, so the bill a test gives the reader stands in for it
The store: every volume, whose it is, and taking out what nothing needsspin admin storage listTestAVolumeNothingNeedsIsTakenOutOfTheStore
Re-key a workspace’s diskspin admin volume rekeyTestARekeyedDiskBootsWithWhatItHeldUnderANewKey
An administrator stops a workspace that is not theirs, moves it off a lost host with a reason its owner reads on its history, reads where it sends, and lists the disks hosts refuse: each auditedspin admin workspace recovernot yet: no lane asks these as an administrator of a real runner: each runs what its owner’s stop, recover and egress run, which the lanes cover, and who may ask, the audit entry and what the owner’s history says are tested at the RPC against the database (workspaceserver’s adminacts tests)
Runners: registration tokens, drain, activate, revoke, and a policy per hostspin admin runner drainTestARunnerRegisteredWithATokenTheAPIMadeIsRevokedByTheAdmin
TestARegistrationTokenExpiredOrRevokedRegistersNothing
Runners start when a workspace waits for one and stop when nothing runsHostService/GetFleetnot yet: an autoscaling group to start and stop: the one group is AWS’s, and no lane has an account
A root shell on a runner, for a while and with a reason: the runner emptied first, every session recorded under Object Lock, the runner retired afterspin admin shell openTestHostsARootShellOnAHostIsRecordedAndItsHostRetired
A host that reboots brings its workspaces backTestAHostRebootBringsItsWorkspacesBack, a test of internal/e2eTestAHostRebootBringsItsWorkspacesBack
A cloud’s reclaim warning empties the host before the machine goesTestACloudsReclaimWarningEmptiesTheHostBeforeAnySignal, a test of internal/e2eTestACloudsReclaimWarningEmptiesTheHostBeforeAnySignal
A writeback bound per host, measured on that host before it is takenTestCustomWritebackValuesAreMeasuredOnTheRunner, a test of internal/e2eTestCustomWritebackValuesAreMeasuredOnTheRunner
What is running where: the control plane, each runner and its machinespin admin versionsTestE2E_Admin
A workspace whose host never comes back is moved when little would be lost, and its owner is told when it waits for themWorkspaceService/RecoverWorkspacenot yet: the move without asking and the wait it records are tested against the database (workspaceserver’s autorehome tests); the hosts lane recovers by hand, and no lane has an SMTP server to receive the owner’s email
FeatureExistsEnd to end
A workspace’s cost this month and its rate, as an estimate with its day, for its owner; a team’s workspaces summed for its admins, and a project’s with its prebuilds’ storage for its admins
A share of days already billed, never of this hour; nothing is said where the cloud sends no bill.
WorkspaceService/GetWorkspaceCostnot yet: the cloud’s real bill read: no lane has an AWS account, so the bill a test gives the reader stands in for it
A workspace’s owner is told by email when it waits for them or something happened to it, each event switchable
Held after its host was lost, a stop that could not be taken, stopped for not responding, moved off a lost host. A disk almost full is not an event yet.
SettingsService/UpdateNotificationPreferencesnot yet: no lane has an SMTP server: delivery is tested against a generated mail server, with every attempt and retry recorded (internal/controlplane/notify)
Platform logs, workspace logs and traces, searched in the productLogService/SearchPlatformLogsTestAWorkspacesLinesAndTracesAreFoundBySearchingForIt
TestE2E_TheInstallationsLogsAreSearchable
Metrics, with Grafana on the control planeAdminService/GetMonitoringadmin.spec.ts: a series of the lane’s host is in the metric store, read through Grafana
admin.spec.ts: admin reads the installation’s dashboards without leaving the page
A workspace’s journal and console are collected as the installation’s policy saysspin workspace logsTestE2E_AWorkspacesConsoleIsKeptAndSearchable
A workspace’s last hour of CPU, memory and network against what it holds, for its owner
Kept on the host, so it starts again with a restart of it or a move; the disk’s use is not sampled.
WorkspaceService/GetWorkspaceUsageTestAWorkspacesUsageIsWhatItsHostSampled
FeatureExistsEnd to end
A smoke test of what an installation’s API promises, with a workspace of its ownspin smokeTestE2E_SmokePassesAndLeavesNothingBehind
A host serves only the releases it carries
A resume whose recorded release was collected since has no test against the stack.
TestAMachineAdoptedWithoutItsReleasesIsSuspendedWithItsDisk, a test of internal/e2eTestAMachineAdoptedWithoutItsReleasesIsSuspendedWithItsDisk
TestAVSCodeServerOfAnotherCommitIsHandedToTheRunningMachine

Nothing today.

Each is an item of docs/ROADMAP.md, with the command that checks it.

  • What a workspace grew to is asked for and never recorded (Workspaces)
  • Placement cannot be told which kind of host a workspace belongs on (Workspaces)

Not planned: a limit of the platform or of where it runs today. Limitations says what each means.

  • AWS only (Platform): The Terraform module is the one supported install; nothing else is packaged or tested.
  • x86-64 only (Platform): Runners are x86-64 machines with nested virtualization.
  • The CLI runs on Linux and macOS (Platform): x86-64 and Arm of each; there is no Windows build.
  • One region, one control plane (Platform): A machine that fails is replaced in minutes, not seconds.
  • No GPUs (Workspaces): A preset names the class of runner its workspaces run on, and no class hands a workspace a GPU.
  • Linux guests only (Workspaces): Booted with the kernel spin provides.
  • No IPv6 inside a workspace (Network)
  • TCP only for published ports (Network)
  • A diff does not see everything (Snapshots): A file is hashed only when its size, inode or times changed; extended attributes are not compared.
  • A memory snapshot resumes only on the same machine (Snapshots): The same QEMU, guest kernel and guest init; a disk restore has no such limit.
  • Disk chains have a limit (Snapshots): At the limit the top layer grows instead, so less of the recent work is in the bucket.
  • Work since the last upload can be lost (Snapshots): A runner uploads writes in layers, on the RPO, on snapshot and on stop; what it had not uploaded goes with it.
  • No multi-factor authentication of Spinbox’s own (Access): Sign in through a provider that enforces it.
  • No team invitations (Access): A person signs in once before they can be added to a team; a workspace’s guests are invited by email.
  • Team roles are fixed (Access): Owner, admin and member.
  • Nothing pages the operator (Observability): Metrics, logs and traces stay inside the installation; alert rules fire in its Grafana and no contact point tells anyone. A workspace’s owner is emailed when it waits for them.
  • An update is one way (Administration): A release older than the one that last started the database refuses to start on it.

Generated by task reference from spin/internal/features/features.go at 51f7e0dea.

Installations run Spinbox v20261027.01; the reference is generated from spin v20261114.01 (51f7e0dea). This page as Markdown, for a model or a terminal.