anchor.diff:  
   A build variant is a selection that applies across all architectures and toolchains (in most cases). An example would be debug vs production.
   
  -Variants provide the mechanism for compiling multiple spores for the same architecture with different collections of settings that apply to all spores. Example use cases that apply here are debug, production, or special test build variants.
  +Variants provide the mechanism for compiling multiple seeds for the same architecture with different collections of settings that apply to all seeds. Example use cases that apply here are debug, production, or special test build variants.
  
positive.code: 
  == Architectures
  
  An architecture definition specifies a toolchain. For example armv5-gcc would specify a gcc cross compiler. And armv5-clang would specify a clang cross compile. In order to build the same spore for the same processor with two different tools, two different architectures must be created.
  
  Architecture is the mechanism for customized compilation of spores for a particular target. Different spores compiled for the same architecture may have different toolchain settings. The architecture is the means of selection. Spores compiled for the same architecture may be linked together. A mixing of architectures is not supported.
  
  A build architecture is defined by a specific CPU type and associated instruction set.
  
  
negative.code: = Moss Design Overview
  
  Moss is a library for GNU make that streamlines the creation of rules and dependencies for software build artifacts. The core concepts within this library are:
  
  1. Seeds - modular units of source code that are formed into an artifact
  2. Artifacts - outputs of seeds which may be created for multiple architectures and variants
  3. Tools - used to compile source code and form artifacts
  4. Architectures - used to specialize seeds and tools for artifact creation
  5. Variants - global switches for tools
  
  == Seeds
  
  A seed describes how Moss produces artifacts from source code and files in an architecture and toolchain independent fashion.
  Seeds do not possess knowledge of Moss build architecture.
  Instead, they are specialized for different architectures through settings.
  
  === Definition
  
  Seeds are defined entirely through variable definition.
  Creation and management of rules and dependencies is managed automatically by Moss.
  Knowledge of toolchain and architecture specifics are decoupled from the description of the software itself.
  Moss manages the creation and application of all makefile rules required for multiple languages, artifacts, architectures, toolchains, and variants.
  