diff --git a/plugins/org.eclipse.app4mc.amalthea.model/.classpath b/plugins/org.eclipse.app4mc.amalthea.model/.classpath
index 15a4e05..d2ff62f 100644
--- a/plugins/org.eclipse.app4mc.amalthea.model/.classpath
+++ b/plugins/org.eclipse.app4mc.amalthea.model/.classpath
@@ -8,5 +8,6 @@
 		</attributes>
 	</classpathentry>
 	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="xtend-gen"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/META-INF/MANIFEST.MF b/plugins/org.eclipse.app4mc.amalthea.model/META-INF/MANIFEST.MF
index e0c963e..322f1ad 100644
--- a/plugins/org.eclipse.app4mc.amalthea.model/META-INF/MANIFEST.MF
+++ b/plugins/org.eclipse.app4mc.amalthea.model/META-INF/MANIFEST.MF
@@ -6,6 +6,7 @@
 Bundle-ClassPath: .
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Export-Package: org.eclipse.app4mc.amalthea.model,
+ org.eclipse.app4mc.amalthea.model.builder,
  org.eclipse.app4mc.amalthea.model.check,
  org.eclipse.app4mc.amalthea.model.impl,
  org.eclipse.app4mc.amalthea.model.io,
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/AmaltheaBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/AmaltheaBuilder.xtend
new file mode 100644
index 0000000..0bb3b88
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/AmaltheaBuilder.xtend
@@ -0,0 +1,85 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+import org.eclipse.app4mc.amalthea.model.Amalthea
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.amalthea.model.CommonElements
+import org.eclipse.app4mc.amalthea.model.ComponentsModel
+import org.eclipse.app4mc.amalthea.model.ConstraintsModel
+import org.eclipse.app4mc.amalthea.model.EventModel
+import org.eclipse.app4mc.amalthea.model.HWModel
+import org.eclipse.app4mc.amalthea.model.IReferable
+import org.eclipse.app4mc.amalthea.model.MappingModel
+import org.eclipse.app4mc.amalthea.model.OSModel
+import org.eclipse.app4mc.amalthea.model.PropertyConstraintsModel
+import org.eclipse.app4mc.amalthea.model.SWModel
+import org.eclipse.app4mc.amalthea.model.StimuliModel
+
+class AmaltheaBuilder {
+
+	val objectRegistry = <String, IReferable> newHashMap
+
+	def amaltheaRoot((Amalthea)=>void initializer) {
+		AmaltheaFactory.eINSTANCE.createAmalthea.init(initializer)
+	}
+
+	// ********** Top level elements **********
+
+	def commonElements(Amalthea container, (CommonElements)=>void initializer) {
+		container.commonElements = AmaltheaFactory.eINSTANCE.createCommonElements.init(initializer)
+	}
+
+	def eventModel(Amalthea container, (EventModel)=>void initializer) {
+		container.eventModel = AmaltheaFactory.eINSTANCE.createEventModel.init(initializer)
+	}
+
+	def stimuliModel(Amalthea container, (StimuliModel)=>void initializer) {
+		container.stimuliModel = AmaltheaFactory.eINSTANCE.createStimuliModel.init(initializer)
+	}
+
+	def softwareModel(Amalthea container, (SWModel)=>void initializer) {
+		container.swModel = AmaltheaFactory.eINSTANCE.createSWModel.init(initializer)
+	}
+
+	def osModel(Amalthea container, (OSModel)=>void initializer) {
+		container.osModel = AmaltheaFactory.eINSTANCE.createOSModel.init(initializer)
+	}
+
+	def hardwareModel(Amalthea container, (HWModel)=>void initializer) {
+		container.hwModel = AmaltheaFactory.eINSTANCE.createHWModel.init(initializer)
+	}
+
+	def constraintsModel(Amalthea container, (ConstraintsModel)=>void initializer) {
+		container.constraintsModel = AmaltheaFactory.eINSTANCE.createConstraintsModel.init(initializer)
+	}
+
+	def propertyConstraintsModel(Amalthea container, (PropertyConstraintsModel)=>void initializer) {
+		container.propertyConstraintsModel = AmaltheaFactory.eINSTANCE.createPropertyConstraintsModel.init(initializer)
+	}
+
+	def componentsModel(Amalthea container, (ComponentsModel)=>void initializer) {
+		container.componentsModel = AmaltheaFactory.eINSTANCE.createComponentsModel.init(initializer)
+	}
+
+	def mappingModel(Amalthea container, (MappingModel)=>void initializer) {
+		container.mappingModel = AmaltheaFactory.eINSTANCE.createMappingModel.init(initializer)
+	}
+
+	// ********** Cross reference registry **********
+	
+	def <T extends IReferable> void register(T obj, String name) {
+		objectRegistry.put(name, obj)
+	}
+	
+	def <T extends IReferable> T ref(Class<T> cl, String name) {
+		val obj = objectRegistry.get(name)	
+		cl.cast(obj)
+	}
+
+	// ********** private **********
+
+	def private <T> T init(T obj, (T)=>void init) {
+		init.apply(obj)
+		return obj
+	}
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/CommonElementsBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/CommonElementsBuilder.xtend
new file mode 100644
index 0000000..8da9a30
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/CommonElementsBuilder.xtend
@@ -0,0 +1,34 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.amalthea.model.CommonElements
+import org.eclipse.app4mc.amalthea.model.CoreClassifier
+import org.eclipse.app4mc.amalthea.model.MemoryClassifier
+import org.eclipse.app4mc.amalthea.model.Tag
+
+class CommonElementsBuilder {
+
+	def commonElementsRoot((CommonElements)=>void initializer) {
+		AmaltheaFactory.eINSTANCE.createCommonElements.init(initializer)
+	}
+
+	// ********** Top level elements **********
+
+	def memoryClassifier(CommonElements container, (MemoryClassifier)=>void initializer) {
+		container.memoryClassifiers += AmaltheaFactory.eINSTANCE.createMemoryClassifier.init(initializer)
+	}
+	def coreClassifier(CommonElements container, (CoreClassifier)=>void initializer) {
+		container.coreClassifiers += AmaltheaFactory.eINSTANCE.createCoreClassifier.init(initializer)
+	}
+	def tag(CommonElements container, (Tag)=>void initializer) {
+		container.tags += AmaltheaFactory.eINSTANCE.createTag.init(initializer)
+	}
+
+	// ********** private **********
+
+	def private <T> T init(T obj, (T)=>void init) {
+		init.apply(obj)
+		return obj
+	}
+		
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/ConstraintsBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/ConstraintsBuilder.xtend
new file mode 100644
index 0000000..6df1998
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/ConstraintsBuilder.xtend
@@ -0,0 +1,5 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+class ConstraintsBuilder {
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/DatatypeBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/DatatypeBuilder.xtend
new file mode 100644
index 0000000..20d304e
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/DatatypeBuilder.xtend
@@ -0,0 +1,113 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.amalthea.model.Array
+import org.eclipse.app4mc.amalthea.model.BaseTypeDefinition
+import org.eclipse.app4mc.amalthea.model.Channel
+import org.eclipse.app4mc.amalthea.model.DataTypeDefinition
+import org.eclipse.app4mc.amalthea.model.Label
+import org.eclipse.app4mc.amalthea.model.Pointer
+import org.eclipse.app4mc.amalthea.model.SWModel
+import org.eclipse.app4mc.amalthea.model.Struct
+import org.eclipse.app4mc.amalthea.model.StructEntry
+
+class DatatypeBuilder {
+
+	def typeDefinition_BaseType(SWModel container, (BaseTypeDefinition)=>void initializer) {
+		container.typeDefinitions += AmaltheaFactory.eINSTANCE.createBaseTypeDefinition.init(initializer)
+	}
+
+	def typeDefinition_DataType(SWModel container, (DataTypeDefinition)=>void initializer) {
+		container.typeDefinitions += AmaltheaFactory.eINSTANCE.createDataTypeDefinition.init(initializer)
+	}
+
+	// ********** Data Types - Struct **********
+
+	def struct(Channel container, (Struct)=>void initializer) {
+		container.elementType = AmaltheaFactory.eINSTANCE.createStruct.init(initializer)
+	}
+
+	def struct(Label container, (Struct)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createStruct.init(initializer)
+	}
+
+	def struct(DataTypeDefinition container, (Struct)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createStruct.init(initializer)
+	}
+
+	def struct(Array container, (Struct)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createStruct.init(initializer)
+	}
+
+	def struct(StructEntry container, (Struct)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createStruct.init(initializer)
+	}
+
+	def struct(Pointer container, (Struct)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createStruct.init(initializer)
+	}
+
+	def entry(Struct container, (StructEntry)=>void initializer) {
+		container.entries += AmaltheaFactory.eINSTANCE.createStructEntry.init(initializer)
+	}
+
+	// ********** Data Types - Array **********
+
+	def array(Channel container, (Array)=>void initializer) {
+		container.elementType = AmaltheaFactory.eINSTANCE.createArray.init(initializer)
+	}
+
+	def array(Label container, (Array)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createArray.init(initializer)
+	}
+
+	def array(DataTypeDefinition container, (Array)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createArray.init(initializer)
+	}
+
+	def array(Array container, (Array)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createArray.init(initializer)
+	}
+
+	def array(StructEntry container, (Array)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createArray.init(initializer)
+	}
+
+	def array(Pointer container, (Array)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createArray.init(initializer)
+	}
+
+	// ********** Data Types - Pointer **********
+
+	def pointer(Channel container, (Pointer)=>void initializer) {
+		container.elementType = AmaltheaFactory.eINSTANCE.createPointer.init(initializer)
+	}
+
+	def pointer(Label container, (Pointer)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createPointer.init(initializer)
+	}
+
+	def pointer(DataTypeDefinition container, (Pointer)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createPointer.init(initializer)
+	}
+
+	def pointer(Array container, (Pointer)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createPointer.init(initializer)
+	}
+
+	def pointer(StructEntry container, (Pointer)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createPointer.init(initializer)
+	}
+
+	def pointer(Pointer container, (Pointer)=>void initializer) {
+		container.dataType = AmaltheaFactory.eINSTANCE.createPointer.init(initializer)
+	}
+
+	// ********** private **********
+
+	def private <T> T init(T obj, (T)=>void init) {
+		init.apply(obj)
+		return obj
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/HardwareBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/HardwareBuilder.xtend
new file mode 100644
index 0000000..0c0ddd2
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/HardwareBuilder.xtend
@@ -0,0 +1,61 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+import org.eclipse.app4mc.amalthea.model.HWModel
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.amalthea.model.CacheDefinition
+import org.eclipse.app4mc.amalthea.model.MemoryDefinition
+import org.eclipse.app4mc.amalthea.model.ProcessingUnitDefinition
+import org.eclipse.app4mc.amalthea.model.ConnectionHandlerDefinition
+import org.eclipse.app4mc.amalthea.model.FrequencyDomain
+import org.eclipse.app4mc.amalthea.model.PowerDomain
+import org.eclipse.app4mc.amalthea.model.HwFeatureCategory
+import org.eclipse.app4mc.amalthea.model.HwStructure
+
+class HardwareBuilder {
+
+	def hardwareModelRoot((HWModel)=>void initializer) {
+		AmaltheaFactory.eINSTANCE.createHWModel.init(initializer)
+	}
+
+	// ********** Top level elements **********
+
+	def definition_Cache(HWModel container, (CacheDefinition)=>void initializer) {
+		container.definitions += AmaltheaFactory.eINSTANCE.createCacheDefinition.init(initializer)
+	}
+
+	def definition_Memory(HWModel container, (MemoryDefinition)=>void initializer) {
+		container.definitions += AmaltheaFactory.eINSTANCE.createMemoryDefinition.init(initializer)
+	}
+
+	def definition_ProcessingUnit(HWModel container, (ProcessingUnitDefinition)=>void initializer) {
+		container.definitions += AmaltheaFactory.eINSTANCE.createProcessingUnitDefinition.init(initializer)
+	}
+
+	def definition_ConnectionHandler(HWModel container, (ConnectionHandlerDefinition)=>void initializer) {
+		container.definitions += AmaltheaFactory.eINSTANCE.createConnectionHandlerDefinition.init(initializer)
+	}
+
+	def domain_Frequency(HWModel container, (FrequencyDomain)=>void initializer) {
+		container.domains += AmaltheaFactory.eINSTANCE.createFrequencyDomain.init(initializer)
+	}
+
+	def domain_Power(HWModel container, (PowerDomain)=>void initializer) {
+		container.domains += AmaltheaFactory.eINSTANCE.createPowerDomain.init(initializer)
+	}
+
+	def featureCategory(HWModel container, (HwFeatureCategory)=>void initializer) {
+		container.featureCategories += AmaltheaFactory.eINSTANCE.createHwFeatureCategory.init(initializer)
+	}
+
+	def structure(HWModel container, (HwStructure)=>void initializer) {
+		container.structures += AmaltheaFactory.eINSTANCE.createHwStructure.init(initializer)
+	}
+
+	// ********** private **********
+
+	def private <T> T init(T obj, (T)=>void init) {
+		init.apply(obj)
+		return obj
+	}
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/InstructionsBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/InstructionsBuilder.xtend
new file mode 100644
index 0000000..59793bd
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/InstructionsBuilder.xtend
@@ -0,0 +1,77 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.amalthea.model.Deviation
+import org.eclipse.app4mc.amalthea.model.Group
+import org.eclipse.app4mc.amalthea.model.HWModel
+import org.eclipse.app4mc.amalthea.model.LongObject
+import org.eclipse.app4mc.amalthea.model.ModeSwitchDefault
+import org.eclipse.app4mc.amalthea.model.ModeSwitchEntry
+import org.eclipse.app4mc.amalthea.model.ProbabilitySwitchEntry
+import org.eclipse.app4mc.amalthea.model.Runnable
+import org.eclipse.app4mc.amalthea.model.RunnableItem
+import org.eclipse.app4mc.amalthea.model.Scheduler
+import org.eclipse.app4mc.amalthea.model.util.InstructionsUtil
+
+class InstructionsBuilder {
+
+	// ********** Runnable Items - Execution Need **********
+
+	def execNeed_default_Instructions(Runnable container, long instructions) {
+		container.runnableItems += InstructionsUtil.createDefaultExecutionNeed(instructions)
+	}
+
+	def execNeed_default_Instructions(Runnable container, Deviation<LongObject> instructions) {
+		container.runnableItems += InstructionsUtil.createDefaultExecutionNeed(instructions)
+	}
+
+	def execNeed_default_Instructions(Group container, long instructions) {
+		container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+	}
+	def execNeed_default_Instructions(Group container, Deviation<LongObject> instructions) {
+		container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+	}
+
+	def execNeed_default_Instructions(ModeSwitchDefault<RunnableItem> container, long instructions) {
+		container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+	}
+
+	def execNeed_default_Instructions(ModeSwitchDefault<RunnableItem> container, Deviation<LongObject> instructions) {
+		container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+	}
+
+	def execNeed_default_Instructions(ModeSwitchEntry<RunnableItem> container, long instructions) {
+		container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+	}
+
+	def execNeed_default_Instructions(ModeSwitchEntry<RunnableItem> container, Deviation<LongObject> instructions) {
+		container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+	}
+
+	def execNeed_default_Instructions(ProbabilitySwitchEntry<RunnableItem> container, long instructions) {
+		container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+	}
+
+	def execNeed_default_Instructions(ProbabilitySwitchEntry<RunnableItem> container, Deviation<LongObject> instructions) {
+		container.items += InstructionsUtil.createDefaultExecutionNeed(instructions)
+	}
+
+	// ********** Computation Items - Execution Need **********
+
+	def execNeed_default_Instructions(Scheduler container, long instructions) {
+		container.computationItems += InstructionsUtil.createDefaultExecutionNeed(instructions)
+	}
+
+	def execNeed_default_Instructions(Scheduler container, Deviation<LongObject> instructions) {
+		container.computationItems += InstructionsUtil.createDefaultExecutionNeed(instructions)
+	}
+
+	// ********** Hardware Feature Category **********
+
+	def featureCategory_Instructions(HWModel container) {
+		val category = AmaltheaFactory.eINSTANCE.createHwFeatureCategory()
+		category.name = InstructionsUtil.INSTRUCTIONS_CATEGORY_NAME
+		container.featureCategories += category
+	}
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/OperatingSystemBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/OperatingSystemBuilder.xtend
new file mode 100644
index 0000000..a6ab012
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/OperatingSystemBuilder.xtend
@@ -0,0 +1,95 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.amalthea.model.InterruptController
+import org.eclipse.app4mc.amalthea.model.LabelAccess
+import org.eclipse.app4mc.amalthea.model.OSModel
+import org.eclipse.app4mc.amalthea.model.OperatingSystem
+import org.eclipse.app4mc.amalthea.model.OsAPIInstructions
+import org.eclipse.app4mc.amalthea.model.OsDataConsistency
+import org.eclipse.app4mc.amalthea.model.OsISRInstructions
+import org.eclipse.app4mc.amalthea.model.OsInstructions
+import org.eclipse.app4mc.amalthea.model.Scheduler
+import org.eclipse.app4mc.amalthea.model.SchedulerAssociation
+import org.eclipse.app4mc.amalthea.model.SchedulingParameters
+import org.eclipse.app4mc.amalthea.model.Semaphore
+import org.eclipse.app4mc.amalthea.model.TaskScheduler
+import org.eclipse.app4mc.amalthea.model.VendorOperatingSystem
+
+class OperatingSystemBuilder {
+
+	def osModelRoot((OSModel)=>void initializer) {
+		AmaltheaFactory.eINSTANCE.createOSModel.init(initializer)
+	}
+
+	// ********** Top level elements **********
+
+	def operatingSystem(OSModel container, (OperatingSystem)=>void initializer) {
+		container.operatingSystems += AmaltheaFactory.eINSTANCE.createOperatingSystem.init(initializer)
+	}
+
+	def operatingSystem_Vendor(OSModel container, (VendorOperatingSystem)=>void initializer) {
+		container.operatingSystems += AmaltheaFactory.eINSTANCE.createVendorOperatingSystem.init(initializer)
+	}
+
+	def semaphore(OSModel container, (Semaphore)=>void initializer) {
+		container.semaphores += AmaltheaFactory.eINSTANCE.createSemaphore.init(initializer)
+	}
+
+	def osOverhead(OSModel container, (OsInstructions)=>void initializer) {
+		container.osOverheads += AmaltheaFactory.eINSTANCE.createOsInstructions.init(initializer)
+	}
+
+	// ********** Operating system **********
+
+	def taskScheduler(OperatingSystem container, (TaskScheduler)=>void initializer) {
+		container.taskSchedulers += AmaltheaFactory.eINSTANCE.createTaskScheduler.init(initializer)
+	}
+
+	def interruptController(OperatingSystem container, (InterruptController)=>void initializer) {
+		container.interruptControllers += AmaltheaFactory.eINSTANCE.createInterruptController.init(initializer)
+	}
+
+	def dataConsistency(OperatingSystem container, (OsDataConsistency)=>void initializer) {
+		container.osDataConsistency = AmaltheaFactory.eINSTANCE.createOsDataConsistency.init(initializer)
+	}
+
+	def labelAccess(Scheduler container, (LabelAccess)=>void initializer) {
+		container.computationItems += AmaltheaFactory.eINSTANCE.createLabelAccess.init(initializer)
+	}
+
+	def parentAssociation(TaskScheduler container, (SchedulerAssociation)=>void initializer) {
+		container.parentAssociation = AmaltheaFactory.eINSTANCE.createSchedulerAssociation.init(initializer)
+	}
+
+	def schedulingParameters(SchedulerAssociation container, (SchedulingParameters)=>void initializer) {
+		container.schedulingParameters = AmaltheaFactory.eINSTANCE.createSchedulingParameters.init(initializer)
+	}
+
+	def parameter_extension(SchedulerAssociation container, String key, String value) {
+		container.parameterExtensions.put(key, value)
+	}
+
+
+	// ********** OS instructions (overhead) **********
+
+	def apiOverhead(OsInstructions container, (OsAPIInstructions)=>void initializer) {
+		container.apiOverhead = AmaltheaFactory.eINSTANCE.createOsAPIInstructions.init(initializer)
+	}
+
+	def isrOverheadCat1(OsInstructions container, (OsISRInstructions)=>void initializer) {
+		container.isrCategory1Overhead = AmaltheaFactory.eINSTANCE.createOsISRInstructions.init(initializer)
+	}
+
+	def isrOverheadCat2(OsInstructions container, (OsISRInstructions)=>void initializer) {
+		container.isrCategory2Overhead = AmaltheaFactory.eINSTANCE.createOsISRInstructions.init(initializer)
+	}
+
+	// ********** private **********
+
+	def private <T> T init(T obj, (T)=>void init) {
+		init.apply(obj)
+		return obj
+	}
+
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/SoftwareBuilder.xtend b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/SoftwareBuilder.xtend
new file mode 100644
index 0000000..9a6e177
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/builder/SoftwareBuilder.xtend
@@ -0,0 +1,245 @@
+package org.eclipse.app4mc.amalthea.model.builder
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory
+import org.eclipse.app4mc.amalthea.model.Channel
+import org.eclipse.app4mc.amalthea.model.CustomActivation
+import org.eclipse.app4mc.amalthea.model.EventActivation
+import org.eclipse.app4mc.amalthea.model.Group
+import org.eclipse.app4mc.amalthea.model.ISR
+import org.eclipse.app4mc.amalthea.model.Label
+import org.eclipse.app4mc.amalthea.model.LabelAccess
+import org.eclipse.app4mc.amalthea.model.Mode
+import org.eclipse.app4mc.amalthea.model.ModeLabel
+import org.eclipse.app4mc.amalthea.model.ModeLiteral
+import org.eclipse.app4mc.amalthea.model.ModeSwitchDefault
+import org.eclipse.app4mc.amalthea.model.ModeSwitchEntry
+import org.eclipse.app4mc.amalthea.model.PeriodicActivation
+import org.eclipse.app4mc.amalthea.model.ProbabilitySwitchEntry
+import org.eclipse.app4mc.amalthea.model.ProcessPrototype
+import org.eclipse.app4mc.amalthea.model.Runnable
+import org.eclipse.app4mc.amalthea.model.RunnableCall
+import org.eclipse.app4mc.amalthea.model.RunnableItem
+import org.eclipse.app4mc.amalthea.model.RunnableModeSwitch
+import org.eclipse.app4mc.amalthea.model.RunnableParameter
+import org.eclipse.app4mc.amalthea.model.RunnableProbabilitySwitch
+import org.eclipse.app4mc.amalthea.model.SWModel
+import org.eclipse.app4mc.amalthea.model.Section
+import org.eclipse.app4mc.amalthea.model.SingleActivation
+import org.eclipse.app4mc.amalthea.model.SporadicActivation
+import org.eclipse.app4mc.amalthea.model.Task
+import org.eclipse.app4mc.amalthea.model.VariableRateActivation
+
+class SoftwareBuilder {
+
+	def softwareModelRoot( (SWModel)=>void initializer) {
+		AmaltheaFactory.eINSTANCE.createSWModel.init(initializer)
+	}
+
+	// ********** Top level elements **********
+
+	def isr(SWModel container, (ISR)=>void initializer) {
+		container.isrs += AmaltheaFactory.eINSTANCE.createISR.init(initializer)
+	}
+
+	def task(SWModel container, (Task)=>void initializer) {
+		container.tasks += AmaltheaFactory.eINSTANCE.createTask.init(initializer)
+	}
+
+	def runnable(SWModel container, (Runnable)=>void initializer) {
+		container.runnables += AmaltheaFactory.eINSTANCE.createRunnable.init(initializer)
+	}
+
+	def label(SWModel container, (Label)=>void initializer) {
+		container.labels += AmaltheaFactory.eINSTANCE.createLabel.init(initializer)
+	}
+
+	def channel(SWModel container, (Channel)=>void initializer) {
+		container.channels += AmaltheaFactory.eINSTANCE.createChannel.init(initializer)
+	}
+
+	def processPrototype(SWModel container, (ProcessPrototype)=>void initializer) {
+		container.processPrototypes += AmaltheaFactory.eINSTANCE.createProcessPrototype.init(initializer)
+	}
+
+	def section(SWModel container, (Section)=>void initializer) {
+		container.sections += AmaltheaFactory.eINSTANCE.createSection.init(initializer)
+	}
+
+	def activation_Single(SWModel container, (SingleActivation)=>void initializer) {
+		container.activations += AmaltheaFactory.eINSTANCE.createSingleActivation.init(initializer)
+	}
+
+	def activation_Sporadic(SWModel container, (SporadicActivation)=>void initializer) {
+		container.activations += AmaltheaFactory.eINSTANCE.createSporadicActivation.init(initializer)
+	}
+
+	def activation_Periodic(SWModel container, (PeriodicActivation)=>void initializer) {
+		container.activations += AmaltheaFactory.eINSTANCE.createPeriodicActivation.init(initializer)
+	}
+
+	def activation_Event(SWModel container, (EventActivation)=>void initializer) {
+		container.activations += AmaltheaFactory.eINSTANCE.createEventActivation.init(initializer)
+	}
+
+	def activation_VariableRate(SWModel container, (VariableRateActivation)=>void initializer) {
+		container.activations += AmaltheaFactory.eINSTANCE.createVariableRateActivation.init(initializer)
+	}
+
+	def activation_Custom(SWModel container, (CustomActivation)=>void initializer) {
+		container.activations += AmaltheaFactory.eINSTANCE.createCustomActivation.init(initializer)
+	}
+
+	def mode(SWModel container, (Mode)=>void initializer) {
+		container.modes += AmaltheaFactory.eINSTANCE.createMode.init(initializer)
+	}
+
+	def modeLabel(SWModel container, (ModeLabel)=>void initializer) {
+		container.modeLabels += AmaltheaFactory.eINSTANCE.createModeLabel.init(initializer)
+	}
+
+	// ********** Mode Literals **********
+
+	def literal(Mode container, (ModeLiteral)=>void initializer) {
+		container.literals += AmaltheaFactory.eINSTANCE.createModeLiteral.init(initializer)
+	}
+
+	// ********** Runnable Parameters **********
+
+	def parameter(Runnable container, (RunnableParameter)=>void initializer) {
+		container.parameters += AmaltheaFactory.eINSTANCE.createRunnableParameter.init(initializer)
+	}
+
+	// ********** Runnable Items - Container - Group **********
+
+	def group(Runnable container, (Group)=>void initializer) {
+		container.runnableItems += AmaltheaFactory.eINSTANCE.createGroup.init(initializer)
+	}
+
+	def group(Group container, (Group)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createGroup.init(initializer)
+	}
+
+	def group(ModeSwitchDefault<RunnableItem> container, (Group)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createGroup.init(initializer)
+	}
+
+	def group(ModeSwitchEntry<RunnableItem> container, (Group)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createGroup.init(initializer)
+	}
+
+	def group(ProbabilitySwitchEntry<RunnableItem> container, (Group)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createGroup.init(initializer)
+	}
+
+	// ********** Runnable Items - Container - RunnableModeSwitch **********
+
+	def modeSwitch(Runnable container, (RunnableModeSwitch)=>void initializer) {
+		container.runnableItems += AmaltheaFactory.eINSTANCE.createRunnableModeSwitch.init(initializer)
+	}
+
+	def modeSwitch(Group container, (RunnableModeSwitch)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createRunnableModeSwitch.init(initializer)
+	}
+
+	def modeSwitch(ModeSwitchDefault<RunnableItem> container, (RunnableModeSwitch)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createRunnableModeSwitch.init(initializer)
+	}
+
+	def modeSwitch(ModeSwitchEntry<RunnableItem> container, (RunnableModeSwitch)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createRunnableModeSwitch.init(initializer)
+	}
+
+	def modeSwitch(ProbabilitySwitchEntry<RunnableItem> container, (RunnableModeSwitch)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createRunnableModeSwitch.init(initializer)
+	}
+
+	def entry(RunnableModeSwitch container, (ModeSwitchEntry<RunnableItem>)=>void initializer) {
+		container.entries += AmaltheaFactory.eINSTANCE.createModeSwitchEntry.init(initializer)
+	}
+
+	def defaultEntry(RunnableModeSwitch container, (ModeSwitchDefault<RunnableItem>)=>void initializer) {
+		container.defaultEntry = AmaltheaFactory.eINSTANCE.createModeSwitchDefault.init(initializer)
+	}
+
+	// ********** Runnable Items - Container - RunnableProbabilitySwitch **********
+
+	def probabilitySwitch(Runnable container, (RunnableProbabilitySwitch)=>void initializer) {
+		container.runnableItems += AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch.init(initializer)
+	}
+
+	def probabilitySwitch(Group container, (RunnableProbabilitySwitch)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch.init(initializer)
+	}
+
+	def probabilitySwitch(ModeSwitchDefault<RunnableItem> container, (RunnableProbabilitySwitch)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch.init(initializer)
+	}
+
+	def probabilitySwitch(ModeSwitchEntry<RunnableItem> container, (RunnableProbabilitySwitch)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch.init(initializer)
+	}
+
+	def probabilitySwitch(ProbabilitySwitchEntry<RunnableItem> container, (RunnableProbabilitySwitch)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch.init(initializer)
+	}
+
+	def entry(RunnableProbabilitySwitch container, (ProbabilitySwitchEntry<RunnableItem>)=>void initializer) {
+		container.entries += AmaltheaFactory.eINSTANCE.createProbabilitySwitchEntry.init(initializer)
+	}
+
+	// ********** Runnable Items - Label access **********
+
+	def labelAccess(Runnable container, (LabelAccess)=>void initializer) {
+		container.runnableItems += AmaltheaFactory.eINSTANCE.createLabelAccess.init(initializer)
+	}
+
+	def labelAccess(Group container, (LabelAccess)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createLabelAccess.init(initializer)
+	}
+
+	def labelAccess(ModeSwitchDefault<RunnableItem> container, (LabelAccess)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createLabelAccess.init(initializer)
+	}
+
+	def labelAccess(ModeSwitchEntry<RunnableItem> container, (LabelAccess)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createLabelAccess.init(initializer)
+	}
+
+	def labelAccess(ProbabilitySwitchEntry<RunnableItem> container, (LabelAccess)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createLabelAccess.init(initializer)
+	}
+
+	// ********** Runnable Items - Runnable call **********
+
+	def runnableCall(Runnable container, (RunnableCall)=>void initializer) {
+		container.runnableItems += AmaltheaFactory.eINSTANCE.createRunnableCall.init(initializer)
+	}
+
+	def runnableCall(Group container, (RunnableCall)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createRunnableCall.init(initializer)
+	}
+
+	def runnableCall(ModeSwitchDefault<RunnableItem> container, (RunnableCall)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createRunnableCall.init(initializer)
+	}
+
+	def runnableCall(ModeSwitchEntry<RunnableItem> container, (RunnableCall)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createRunnableCall.init(initializer)
+	}
+
+	def runnableCall(ProbabilitySwitchEntry<RunnableItem> container, (RunnableCall)=>void initializer) {
+		container.items += AmaltheaFactory.eINSTANCE.createRunnableCall.init(initializer)
+	}
+
+	// ********** Runnable Items - TODO **********
+
+
+
+	// ********** private **********
+
+	def private <T> T init(T obj, (T)=>void init) {
+		init.apply(obj)
+		return obj
+	}
+	
+}
\ No newline at end of file
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/CustomPropertyUtil.java b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/CustomPropertyUtil.java
index bc8cff3..312faaa 100644
--- a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/CustomPropertyUtil.java
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/CustomPropertyUtil.java
@@ -17,8 +17,11 @@
 
 import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
 import org.eclipse.app4mc.amalthea.model.IAnnotatable;
+import org.eclipse.app4mc.amalthea.model.IReferable;
 import org.eclipse.app4mc.amalthea.model.IntegerObject;
+import org.eclipse.app4mc.amalthea.model.ReferenceObject;
 import org.eclipse.app4mc.amalthea.model.StringObject;
+import org.eclipse.app4mc.amalthea.model.Time;
 import org.eclipse.app4mc.amalthea.model.Value;
 
 public final class CustomPropertyUtil {
@@ -31,7 +34,7 @@
 		
 		return oldValue;
 	}
-	
+
 	public static Value customPut(IAnnotatable object, String key, String str) {
 		StringObject valueObject;
 		valueObject = AmaltheaFactory.eINSTANCE.createStringObject();
@@ -40,7 +43,26 @@
 		
 		return oldValue;
 	}
-	
+
+	public static Value customPut(IAnnotatable object, String key, Time time) {
+		Time valueObject;
+		valueObject = AmaltheaFactory.eINSTANCE.createTime();
+		valueObject.setValue(time.getValue());
+		valueObject.setUnit(time.getUnit());
+		Value oldValue = object.getCustomProperties().put(key, valueObject);
+		
+		return oldValue;
+	}
+
+	public static Value customPut(IAnnotatable object, String key, IReferable reference) {
+		ReferenceObject valueObject;
+		valueObject = AmaltheaFactory.eINSTANCE.createReferenceObject();
+		valueObject.setValue(reference);
+		Value oldValue = object.getCustomProperties().put(key, valueObject);
+		
+		return oldValue;
+	}
+
 	public static Integer customGetInteger(IAnnotatable object, String key) {
 		Value valueObject = object.getCustomProperties().get(key);
 		if (valueObject instanceof IntegerObject) {
@@ -59,4 +81,26 @@
 		}
 	}
 
+	public static Time customGetTime(IAnnotatable object, String key) {
+		Value valueObject = object.getCustomProperties().get(key);
+		if (valueObject instanceof Time) {
+			Time time = (Time) valueObject;
+			Time result = AmaltheaFactory.eINSTANCE.createTime();
+			result.setValue(time.getValue());
+			result.setUnit(time.getUnit());
+			return result;
+		} else {
+			return null;
+		}
+	}
+
+	public static IReferable customGetReference(IAnnotatable object, String key) {
+		Value valueObject = object.getCustomProperties().get(key);
+		if (valueObject instanceof ReferenceObject) {
+			return ((ReferenceObject) valueObject).getValue();
+		} else {
+			return null;
+		}
+	}
+
 }
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/FactoryUtil.java b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/FactoryUtil.java
index c3b8815..75a94ab 100644
--- a/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/FactoryUtil.java
+++ b/plugins/org.eclipse.app4mc.amalthea.model/src/org/eclipse/app4mc/amalthea/model/util/FactoryUtil.java
@@ -21,20 +21,115 @@
 import java.util.regex.Pattern;
 
 import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.DataSize;
+import org.eclipse.app4mc.amalthea.model.DataSizeUnit;
 import org.eclipse.app4mc.amalthea.model.Deviation;
 import org.eclipse.app4mc.amalthea.model.ExecutionNeed;
+import org.eclipse.app4mc.amalthea.model.Frequency;
+import org.eclipse.app4mc.amalthea.model.FrequencyUnit;
 import org.eclipse.app4mc.amalthea.model.HwFeature;
+import org.eclipse.app4mc.amalthea.model.LatencyConstant;
+import org.eclipse.app4mc.amalthea.model.LatencyDeviation;
 import org.eclipse.app4mc.amalthea.model.LongObject;
 import org.eclipse.app4mc.amalthea.model.Need;
 import org.eclipse.app4mc.amalthea.model.NeedConstant;
 import org.eclipse.app4mc.amalthea.model.NeedDeviation;
 import org.eclipse.app4mc.amalthea.model.Time;
 import org.eclipse.app4mc.amalthea.model.TimeUnit;
+import org.eclipse.app4mc.amalthea.model.TypeDefinition;
+import org.eclipse.app4mc.amalthea.model.TypeRef;
+import org.eclipse.app4mc.amalthea.model.Voltage;
+import org.eclipse.app4mc.amalthea.model.VoltageUnit;
 import org.eclipse.app4mc.amalthea.model.WeibullEstimators;
 
 public class FactoryUtil {
 
 	/**
+	 * Creates a data size out of a value and a unit
+	 * @param value
+	 * @param unit
+	 * @return DataSize
+	 */
+	public static DataSize createDataSize(long value, DataSizeUnit unit) {
+		DataSize size = AmaltheaFactory.eINSTANCE.createDataSize();
+		size.setValue(BigInteger.valueOf(value));
+		size.setUnit(unit);
+		return size;
+	}
+	
+	/**
+	 * Creates a frequency out of a value and a unit
+	 * @param value
+	 * @param unit
+	 * @return Frequency
+	 */
+	public static Frequency createFrequency(double value, FrequencyUnit unit) {
+		Frequency frequency = AmaltheaFactory.eINSTANCE.createFrequency();
+		frequency.setValue(value);
+		frequency.setUnit(unit);
+		return frequency;
+	}
+	
+	/**
+	 * Creates a voltage out of a value and a unit
+	 * @param value
+	 * @param unit
+	 * @return Voltage
+	 */
+	public static Voltage createVoltage(double value, VoltageUnit unit) {
+		Voltage voltage = AmaltheaFactory.eINSTANCE.createVoltage();
+		voltage.setValue(value);
+		voltage.setUnit(unit);
+		return voltage;
+	}
+
+	/**
+	 * Creates a time out of a value and a unit
+	 * @param value
+	 * @param unit
+	 * @return Time
+	 */
+	public static Time createTime(long value, TimeUnit unit) {
+		Time time = AmaltheaFactory.eINSTANCE.createTime();
+		time.setValue(BigInteger.valueOf(value));
+		time.setUnit(unit);
+		return time;
+	}
+
+	/**
+	 * Creates a TypeRef object that refers to a type definition
+	 * @param typeDefinition
+	 * @return TypeRef
+	 */
+	public static TypeRef createTypeRef(TypeDefinition typeDefinition) {
+		TypeRef refObj = AmaltheaFactory.eINSTANCE.createTypeRef();
+		refObj.setTypeDef(typeDefinition);;
+		return refObj;
+	}
+
+	/**
+	 * Creates a HwLatency with constant cycles
+	 * @param cycles
+	 * @return LatencyConstant
+	 */
+	public static LatencyConstant createLatency(long cycles) {
+		LatencyConstant latency = AmaltheaFactory.eINSTANCE.createLatencyConstant();
+		latency.setCycles(cycles);
+		return latency;
+	}
+
+	/**
+	 * Creates a HwLatency with a deviation of cycles
+	 * @param cycles
+	 * @return LatencyDeviation
+	 */
+	public static LatencyDeviation createLatency(Deviation<LongObject> cycles) {
+		LatencyDeviation latency = AmaltheaFactory.eINSTANCE.createLatencyDeviation();
+		latency.setCycles(cycles);;
+		return latency;
+	}
+
+	/**
 	 * Creates a time out of a value and a unit given as String (lower case).
 	 * @param value
 	 * @param unit
@@ -51,7 +146,7 @@
 		
 		return TimeUtil.adjustTimeUnit(BigInteger.valueOf(value), tu);
 	}
-	
+
 	public static Time createTime(BigInteger value, String unit) {
 		TimeUnit tu = null;
 		if(unit.toLowerCase().equals("ps")) tu = TimeUnit.PS;
@@ -63,7 +158,7 @@
 		
 		return TimeUtil.adjustTimeUnit(new BigInteger(value.toByteArray()), tu);
 	}
-	
+
 	/**
 	 * Creates a Time object parsed from a text representation. 
 	 * @param timeString string representation of a time (number follwed by time unit s, ms, us, ns or ps)  
@@ -87,7 +182,7 @@
 		time.setUnit(inputTime.getUnit());
 		return time;
 	}
-	
+
 	/**
 	 * 
 	 * @param executionNeedCount	absolute number of executionNeedCount (simular to instructions)
@@ -109,7 +204,6 @@
 
 		return TimeUtil.adjustTimeUnit(runtime, units.get(timeUnitIndex));
 	}
-	
 
 	/**
 	 * Returns a created Weibull Deviation.
@@ -129,9 +223,7 @@
 		result.setLowerBound(lB);
 		return result;
 	}
-	
-	
-	
+
 	/**
 	 * Returns a created Weibull Estimator.
 	 * @param avgR
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/AmaltheaBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/AmaltheaBuilder.java
new file mode 100644
index 0000000..aa48aee
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/AmaltheaBuilder.java
@@ -0,0 +1,85 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+import java.util.HashMap;
+import org.eclipse.app4mc.amalthea.model.Amalthea;
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.CommonElements;
+import org.eclipse.app4mc.amalthea.model.ComponentsModel;
+import org.eclipse.app4mc.amalthea.model.ConstraintsModel;
+import org.eclipse.app4mc.amalthea.model.EventModel;
+import org.eclipse.app4mc.amalthea.model.HWModel;
+import org.eclipse.app4mc.amalthea.model.IReferable;
+import org.eclipse.app4mc.amalthea.model.MappingModel;
+import org.eclipse.app4mc.amalthea.model.OSModel;
+import org.eclipse.app4mc.amalthea.model.PropertyConstraintsModel;
+import org.eclipse.app4mc.amalthea.model.SWModel;
+import org.eclipse.app4mc.amalthea.model.StimuliModel;
+import org.eclipse.xtext.xbase.lib.CollectionLiterals;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class AmaltheaBuilder {
+  private final HashMap<String, IReferable> objectRegistry = CollectionLiterals.<String, IReferable>newHashMap();
+  
+  public Amalthea amaltheaRoot(final Procedure1<? super Amalthea> initializer) {
+    return this.<Amalthea>init(AmaltheaFactory.eINSTANCE.createAmalthea(), initializer);
+  }
+  
+  public void commonElements(final Amalthea container, final Procedure1<? super CommonElements> initializer) {
+    container.setCommonElements(this.<CommonElements>init(AmaltheaFactory.eINSTANCE.createCommonElements(), initializer));
+  }
+  
+  public void eventModel(final Amalthea container, final Procedure1<? super EventModel> initializer) {
+    container.setEventModel(this.<EventModel>init(AmaltheaFactory.eINSTANCE.createEventModel(), initializer));
+  }
+  
+  public void stimuliModel(final Amalthea container, final Procedure1<? super StimuliModel> initializer) {
+    container.setStimuliModel(this.<StimuliModel>init(AmaltheaFactory.eINSTANCE.createStimuliModel(), initializer));
+  }
+  
+  public void softwareModel(final Amalthea container, final Procedure1<? super SWModel> initializer) {
+    container.setSwModel(this.<SWModel>init(AmaltheaFactory.eINSTANCE.createSWModel(), initializer));
+  }
+  
+  public void osModel(final Amalthea container, final Procedure1<? super OSModel> initializer) {
+    container.setOsModel(this.<OSModel>init(AmaltheaFactory.eINSTANCE.createOSModel(), initializer));
+  }
+  
+  public void hardwareModel(final Amalthea container, final Procedure1<? super HWModel> initializer) {
+    container.setHwModel(this.<HWModel>init(AmaltheaFactory.eINSTANCE.createHWModel(), initializer));
+  }
+  
+  public void constraintsModel(final Amalthea container, final Procedure1<? super ConstraintsModel> initializer) {
+    container.setConstraintsModel(this.<ConstraintsModel>init(AmaltheaFactory.eINSTANCE.createConstraintsModel(), initializer));
+  }
+  
+  public void propertyConstraintsModel(final Amalthea container, final Procedure1<? super PropertyConstraintsModel> initializer) {
+    container.setPropertyConstraintsModel(this.<PropertyConstraintsModel>init(AmaltheaFactory.eINSTANCE.createPropertyConstraintsModel(), initializer));
+  }
+  
+  public void componentsModel(final Amalthea container, final Procedure1<? super ComponentsModel> initializer) {
+    container.setComponentsModel(this.<ComponentsModel>init(AmaltheaFactory.eINSTANCE.createComponentsModel(), initializer));
+  }
+  
+  public void mappingModel(final Amalthea container, final Procedure1<? super MappingModel> initializer) {
+    container.setMappingModel(this.<MappingModel>init(AmaltheaFactory.eINSTANCE.createMappingModel(), initializer));
+  }
+  
+  public <T extends IReferable> void register(final T obj, final String name) {
+    this.objectRegistry.put(name, obj);
+  }
+  
+  public <T extends IReferable> T ref(final Class<T> cl, final String name) {
+    T _xblockexpression = null;
+    {
+      final IReferable obj = this.objectRegistry.get(name);
+      _xblockexpression = cl.cast(obj);
+    }
+    return _xblockexpression;
+  }
+  
+  private <T extends Object> T init(final T obj, final Procedure1<? super T> init) {
+    init.apply(obj);
+    return obj;
+  }
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/CommonElementsBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/CommonElementsBuilder.java
new file mode 100644
index 0000000..6b7bc2b
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/CommonElementsBuilder.java
@@ -0,0 +1,39 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.CommonElements;
+import org.eclipse.app4mc.amalthea.model.CoreClassifier;
+import org.eclipse.app4mc.amalthea.model.MemoryClassifier;
+import org.eclipse.app4mc.amalthea.model.Tag;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class CommonElementsBuilder {
+  public CommonElements commonElementsRoot(final Procedure1<? super CommonElements> initializer) {
+    return this.<CommonElements>init(AmaltheaFactory.eINSTANCE.createCommonElements(), initializer);
+  }
+  
+  public boolean memoryClassifier(final CommonElements container, final Procedure1<? super MemoryClassifier> initializer) {
+    EList<MemoryClassifier> _memoryClassifiers = container.getMemoryClassifiers();
+    MemoryClassifier _init = this.<MemoryClassifier>init(AmaltheaFactory.eINSTANCE.createMemoryClassifier(), initializer);
+    return _memoryClassifiers.add(_init);
+  }
+  
+  public boolean coreClassifier(final CommonElements container, final Procedure1<? super CoreClassifier> initializer) {
+    EList<CoreClassifier> _coreClassifiers = container.getCoreClassifiers();
+    CoreClassifier _init = this.<CoreClassifier>init(AmaltheaFactory.eINSTANCE.createCoreClassifier(), initializer);
+    return _coreClassifiers.add(_init);
+  }
+  
+  public boolean tag(final CommonElements container, final Procedure1<? super Tag> initializer) {
+    EList<Tag> _tags = container.getTags();
+    Tag _init = this.<Tag>init(AmaltheaFactory.eINSTANCE.createTag(), initializer);
+    return _tags.add(_init);
+  }
+  
+  private <T extends Object> T init(final T obj, final Procedure1<? super T> init) {
+    init.apply(obj);
+    return obj;
+  }
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/ConstraintsBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/ConstraintsBuilder.java
new file mode 100644
index 0000000..9d4ecc2
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/ConstraintsBuilder.java
@@ -0,0 +1,5 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+@SuppressWarnings("all")
+public class ConstraintsBuilder {
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/DatatypeBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/DatatypeBuilder.java
new file mode 100644
index 0000000..04263e3
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/DatatypeBuilder.java
@@ -0,0 +1,113 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.Array;
+import org.eclipse.app4mc.amalthea.model.BaseTypeDefinition;
+import org.eclipse.app4mc.amalthea.model.Channel;
+import org.eclipse.app4mc.amalthea.model.DataTypeDefinition;
+import org.eclipse.app4mc.amalthea.model.Label;
+import org.eclipse.app4mc.amalthea.model.Pointer;
+import org.eclipse.app4mc.amalthea.model.SWModel;
+import org.eclipse.app4mc.amalthea.model.Struct;
+import org.eclipse.app4mc.amalthea.model.StructEntry;
+import org.eclipse.app4mc.amalthea.model.TypeDefinition;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class DatatypeBuilder {
+  public boolean typeDefinition_BaseType(final SWModel container, final Procedure1<? super BaseTypeDefinition> initializer) {
+    EList<TypeDefinition> _typeDefinitions = container.getTypeDefinitions();
+    BaseTypeDefinition _init = this.<BaseTypeDefinition>init(AmaltheaFactory.eINSTANCE.createBaseTypeDefinition(), initializer);
+    return _typeDefinitions.add(_init);
+  }
+  
+  public boolean typeDefinition_DataType(final SWModel container, final Procedure1<? super DataTypeDefinition> initializer) {
+    EList<TypeDefinition> _typeDefinitions = container.getTypeDefinitions();
+    DataTypeDefinition _init = this.<DataTypeDefinition>init(AmaltheaFactory.eINSTANCE.createDataTypeDefinition(), initializer);
+    return _typeDefinitions.add(_init);
+  }
+  
+  public void struct(final Channel container, final Procedure1<? super Struct> initializer) {
+    container.setElementType(this.<Struct>init(AmaltheaFactory.eINSTANCE.createStruct(), initializer));
+  }
+  
+  public void struct(final Label container, final Procedure1<? super Struct> initializer) {
+    container.setDataType(this.<Struct>init(AmaltheaFactory.eINSTANCE.createStruct(), initializer));
+  }
+  
+  public void struct(final DataTypeDefinition container, final Procedure1<? super Struct> initializer) {
+    container.setDataType(this.<Struct>init(AmaltheaFactory.eINSTANCE.createStruct(), initializer));
+  }
+  
+  public void struct(final Array container, final Procedure1<? super Struct> initializer) {
+    container.setDataType(this.<Struct>init(AmaltheaFactory.eINSTANCE.createStruct(), initializer));
+  }
+  
+  public void struct(final StructEntry container, final Procedure1<? super Struct> initializer) {
+    container.setDataType(this.<Struct>init(AmaltheaFactory.eINSTANCE.createStruct(), initializer));
+  }
+  
+  public void struct(final Pointer container, final Procedure1<? super Struct> initializer) {
+    container.setDataType(this.<Struct>init(AmaltheaFactory.eINSTANCE.createStruct(), initializer));
+  }
+  
+  public boolean entry(final Struct container, final Procedure1<? super StructEntry> initializer) {
+    EList<StructEntry> _entries = container.getEntries();
+    StructEntry _init = this.<StructEntry>init(AmaltheaFactory.eINSTANCE.createStructEntry(), initializer);
+    return _entries.add(_init);
+  }
+  
+  public void array(final Channel container, final Procedure1<? super Array> initializer) {
+    container.setElementType(this.<Array>init(AmaltheaFactory.eINSTANCE.createArray(), initializer));
+  }
+  
+  public void array(final Label container, final Procedure1<? super Array> initializer) {
+    container.setDataType(this.<Array>init(AmaltheaFactory.eINSTANCE.createArray(), initializer));
+  }
+  
+  public void array(final DataTypeDefinition container, final Procedure1<? super Array> initializer) {
+    container.setDataType(this.<Array>init(AmaltheaFactory.eINSTANCE.createArray(), initializer));
+  }
+  
+  public void array(final Array container, final Procedure1<? super Array> initializer) {
+    container.setDataType(this.<Array>init(AmaltheaFactory.eINSTANCE.createArray(), initializer));
+  }
+  
+  public void array(final StructEntry container, final Procedure1<? super Array> initializer) {
+    container.setDataType(this.<Array>init(AmaltheaFactory.eINSTANCE.createArray(), initializer));
+  }
+  
+  public void array(final Pointer container, final Procedure1<? super Array> initializer) {
+    container.setDataType(this.<Array>init(AmaltheaFactory.eINSTANCE.createArray(), initializer));
+  }
+  
+  public void pointer(final Channel container, final Procedure1<? super Pointer> initializer) {
+    container.setElementType(this.<Pointer>init(AmaltheaFactory.eINSTANCE.createPointer(), initializer));
+  }
+  
+  public void pointer(final Label container, final Procedure1<? super Pointer> initializer) {
+    container.setDataType(this.<Pointer>init(AmaltheaFactory.eINSTANCE.createPointer(), initializer));
+  }
+  
+  public void pointer(final DataTypeDefinition container, final Procedure1<? super Pointer> initializer) {
+    container.setDataType(this.<Pointer>init(AmaltheaFactory.eINSTANCE.createPointer(), initializer));
+  }
+  
+  public void pointer(final Array container, final Procedure1<? super Pointer> initializer) {
+    container.setDataType(this.<Pointer>init(AmaltheaFactory.eINSTANCE.createPointer(), initializer));
+  }
+  
+  public void pointer(final StructEntry container, final Procedure1<? super Pointer> initializer) {
+    container.setDataType(this.<Pointer>init(AmaltheaFactory.eINSTANCE.createPointer(), initializer));
+  }
+  
+  public void pointer(final Pointer container, final Procedure1<? super Pointer> initializer) {
+    container.setDataType(this.<Pointer>init(AmaltheaFactory.eINSTANCE.createPointer(), initializer));
+  }
+  
+  private <T extends Object> T init(final T obj, final Procedure1<? super T> init) {
+    init.apply(obj);
+    return obj;
+  }
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/HardwareBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/HardwareBuilder.java
new file mode 100644
index 0000000..8a30f34
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/HardwareBuilder.java
@@ -0,0 +1,76 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.CacheDefinition;
+import org.eclipse.app4mc.amalthea.model.ConnectionHandlerDefinition;
+import org.eclipse.app4mc.amalthea.model.FrequencyDomain;
+import org.eclipse.app4mc.amalthea.model.HWModel;
+import org.eclipse.app4mc.amalthea.model.HwDefinition;
+import org.eclipse.app4mc.amalthea.model.HwDomain;
+import org.eclipse.app4mc.amalthea.model.HwFeatureCategory;
+import org.eclipse.app4mc.amalthea.model.HwStructure;
+import org.eclipse.app4mc.amalthea.model.MemoryDefinition;
+import org.eclipse.app4mc.amalthea.model.PowerDomain;
+import org.eclipse.app4mc.amalthea.model.ProcessingUnitDefinition;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class HardwareBuilder {
+  public HWModel hardwareModelRoot(final Procedure1<? super HWModel> initializer) {
+    return this.<HWModel>init(AmaltheaFactory.eINSTANCE.createHWModel(), initializer);
+  }
+  
+  public boolean definition_Cache(final HWModel container, final Procedure1<? super CacheDefinition> initializer) {
+    EList<HwDefinition> _definitions = container.getDefinitions();
+    CacheDefinition _init = this.<CacheDefinition>init(AmaltheaFactory.eINSTANCE.createCacheDefinition(), initializer);
+    return _definitions.add(_init);
+  }
+  
+  public boolean definition_Memory(final HWModel container, final Procedure1<? super MemoryDefinition> initializer) {
+    EList<HwDefinition> _definitions = container.getDefinitions();
+    MemoryDefinition _init = this.<MemoryDefinition>init(AmaltheaFactory.eINSTANCE.createMemoryDefinition(), initializer);
+    return _definitions.add(_init);
+  }
+  
+  public boolean definition_ProcessingUnit(final HWModel container, final Procedure1<? super ProcessingUnitDefinition> initializer) {
+    EList<HwDefinition> _definitions = container.getDefinitions();
+    ProcessingUnitDefinition _init = this.<ProcessingUnitDefinition>init(AmaltheaFactory.eINSTANCE.createProcessingUnitDefinition(), initializer);
+    return _definitions.add(_init);
+  }
+  
+  public boolean definition_ConnectionHandler(final HWModel container, final Procedure1<? super ConnectionHandlerDefinition> initializer) {
+    EList<HwDefinition> _definitions = container.getDefinitions();
+    ConnectionHandlerDefinition _init = this.<ConnectionHandlerDefinition>init(AmaltheaFactory.eINSTANCE.createConnectionHandlerDefinition(), initializer);
+    return _definitions.add(_init);
+  }
+  
+  public boolean domain_Frequency(final HWModel container, final Procedure1<? super FrequencyDomain> initializer) {
+    EList<HwDomain> _domains = container.getDomains();
+    FrequencyDomain _init = this.<FrequencyDomain>init(AmaltheaFactory.eINSTANCE.createFrequencyDomain(), initializer);
+    return _domains.add(_init);
+  }
+  
+  public boolean domain_Power(final HWModel container, final Procedure1<? super PowerDomain> initializer) {
+    EList<HwDomain> _domains = container.getDomains();
+    PowerDomain _init = this.<PowerDomain>init(AmaltheaFactory.eINSTANCE.createPowerDomain(), initializer);
+    return _domains.add(_init);
+  }
+  
+  public boolean featureCategory(final HWModel container, final Procedure1<? super HwFeatureCategory> initializer) {
+    EList<HwFeatureCategory> _featureCategories = container.getFeatureCategories();
+    HwFeatureCategory _init = this.<HwFeatureCategory>init(AmaltheaFactory.eINSTANCE.createHwFeatureCategory(), initializer);
+    return _featureCategories.add(_init);
+  }
+  
+  public boolean structure(final HWModel container, final Procedure1<? super HwStructure> initializer) {
+    EList<HwStructure> _structures = container.getStructures();
+    HwStructure _init = this.<HwStructure>init(AmaltheaFactory.eINSTANCE.createHwStructure(), initializer);
+    return _structures.add(_init);
+  }
+  
+  private <T extends Object> T init(final T obj, final Procedure1<? super T> init) {
+    init.apply(obj);
+    return obj;
+  }
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/InstructionsBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/InstructionsBuilder.java
new file mode 100644
index 0000000..a0f90c4
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/InstructionsBuilder.java
@@ -0,0 +1,103 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.ComputationItem;
+import org.eclipse.app4mc.amalthea.model.Deviation;
+import org.eclipse.app4mc.amalthea.model.ExecutionNeed;
+import org.eclipse.app4mc.amalthea.model.Group;
+import org.eclipse.app4mc.amalthea.model.HWModel;
+import org.eclipse.app4mc.amalthea.model.HwFeatureCategory;
+import org.eclipse.app4mc.amalthea.model.LongObject;
+import org.eclipse.app4mc.amalthea.model.ModeSwitchDefault;
+import org.eclipse.app4mc.amalthea.model.ModeSwitchEntry;
+import org.eclipse.app4mc.amalthea.model.ProbabilitySwitchEntry;
+import org.eclipse.app4mc.amalthea.model.RunnableItem;
+import org.eclipse.app4mc.amalthea.model.Scheduler;
+import org.eclipse.app4mc.amalthea.model.util.InstructionsUtil;
+import org.eclipse.emf.common.util.EList;
+
+@SuppressWarnings("all")
+public class InstructionsBuilder {
+  public boolean execNeed_default_Instructions(final org.eclipse.app4mc.amalthea.model.Runnable container, final long instructions) {
+    EList<RunnableItem> _runnableItems = container.getRunnableItems();
+    ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+    return _runnableItems.add(_createDefaultExecutionNeed);
+  }
+  
+  public boolean execNeed_default_Instructions(final org.eclipse.app4mc.amalthea.model.Runnable container, final Deviation<LongObject> instructions) {
+    EList<RunnableItem> _runnableItems = container.getRunnableItems();
+    ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+    return _runnableItems.add(_createDefaultExecutionNeed);
+  }
+  
+  public boolean execNeed_default_Instructions(final Group container, final long instructions) {
+    EList<RunnableItem> _items = container.getItems();
+    ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+    return _items.add(_createDefaultExecutionNeed);
+  }
+  
+  public boolean execNeed_default_Instructions(final Group container, final Deviation<LongObject> instructions) {
+    EList<RunnableItem> _items = container.getItems();
+    ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+    return _items.add(_createDefaultExecutionNeed);
+  }
+  
+  public boolean execNeed_default_Instructions(final ModeSwitchDefault<RunnableItem> container, final long instructions) {
+    EList<RunnableItem> _items = container.getItems();
+    ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+    return _items.add(_createDefaultExecutionNeed);
+  }
+  
+  public boolean execNeed_default_Instructions(final ModeSwitchDefault<RunnableItem> container, final Deviation<LongObject> instructions) {
+    EList<RunnableItem> _items = container.getItems();
+    ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+    return _items.add(_createDefaultExecutionNeed);
+  }
+  
+  public boolean execNeed_default_Instructions(final ModeSwitchEntry<RunnableItem> container, final long instructions) {
+    EList<RunnableItem> _items = container.getItems();
+    ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+    return _items.add(_createDefaultExecutionNeed);
+  }
+  
+  public boolean execNeed_default_Instructions(final ModeSwitchEntry<RunnableItem> container, final Deviation<LongObject> instructions) {
+    EList<RunnableItem> _items = container.getItems();
+    ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+    return _items.add(_createDefaultExecutionNeed);
+  }
+  
+  public boolean execNeed_default_Instructions(final ProbabilitySwitchEntry<RunnableItem> container, final long instructions) {
+    EList<RunnableItem> _items = container.getItems();
+    ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+    return _items.add(_createDefaultExecutionNeed);
+  }
+  
+  public boolean execNeed_default_Instructions(final ProbabilitySwitchEntry<RunnableItem> container, final Deviation<LongObject> instructions) {
+    EList<RunnableItem> _items = container.getItems();
+    ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+    return _items.add(_createDefaultExecutionNeed);
+  }
+  
+  public boolean execNeed_default_Instructions(final Scheduler container, final long instructions) {
+    EList<ComputationItem> _computationItems = container.getComputationItems();
+    ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+    return _computationItems.add(_createDefaultExecutionNeed);
+  }
+  
+  public boolean execNeed_default_Instructions(final Scheduler container, final Deviation<LongObject> instructions) {
+    EList<ComputationItem> _computationItems = container.getComputationItems();
+    ExecutionNeed _createDefaultExecutionNeed = InstructionsUtil.createDefaultExecutionNeed(instructions);
+    return _computationItems.add(_createDefaultExecutionNeed);
+  }
+  
+  public boolean featureCategory_Instructions(final HWModel container) {
+    boolean _xblockexpression = false;
+    {
+      final HwFeatureCategory category = AmaltheaFactory.eINSTANCE.createHwFeatureCategory();
+      category.setName(InstructionsUtil.INSTRUCTIONS_CATEGORY_NAME);
+      EList<HwFeatureCategory> _featureCategories = container.getFeatureCategories();
+      _xblockexpression = _featureCategories.add(category);
+    }
+    return _xblockexpression;
+  }
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/OperatingSystemBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/OperatingSystemBuilder.java
new file mode 100644
index 0000000..91f90d8
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/OperatingSystemBuilder.java
@@ -0,0 +1,102 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.ComputationItem;
+import org.eclipse.app4mc.amalthea.model.InterruptController;
+import org.eclipse.app4mc.amalthea.model.LabelAccess;
+import org.eclipse.app4mc.amalthea.model.OSModel;
+import org.eclipse.app4mc.amalthea.model.OperatingSystem;
+import org.eclipse.app4mc.amalthea.model.OsAPIInstructions;
+import org.eclipse.app4mc.amalthea.model.OsDataConsistency;
+import org.eclipse.app4mc.amalthea.model.OsISRInstructions;
+import org.eclipse.app4mc.amalthea.model.OsInstructions;
+import org.eclipse.app4mc.amalthea.model.Scheduler;
+import org.eclipse.app4mc.amalthea.model.SchedulerAssociation;
+import org.eclipse.app4mc.amalthea.model.SchedulingParameters;
+import org.eclipse.app4mc.amalthea.model.Semaphore;
+import org.eclipse.app4mc.amalthea.model.TaskScheduler;
+import org.eclipse.app4mc.amalthea.model.VendorOperatingSystem;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class OperatingSystemBuilder {
+  public OSModel osModelRoot(final Procedure1<? super OSModel> initializer) {
+    return this.<OSModel>init(AmaltheaFactory.eINSTANCE.createOSModel(), initializer);
+  }
+  
+  public boolean operatingSystem(final OSModel container, final Procedure1<? super OperatingSystem> initializer) {
+    EList<OperatingSystem> _operatingSystems = container.getOperatingSystems();
+    OperatingSystem _init = this.<OperatingSystem>init(AmaltheaFactory.eINSTANCE.createOperatingSystem(), initializer);
+    return _operatingSystems.add(_init);
+  }
+  
+  public boolean operatingSystem_Vendor(final OSModel container, final Procedure1<? super VendorOperatingSystem> initializer) {
+    EList<OperatingSystem> _operatingSystems = container.getOperatingSystems();
+    VendorOperatingSystem _init = this.<VendorOperatingSystem>init(AmaltheaFactory.eINSTANCE.createVendorOperatingSystem(), initializer);
+    return _operatingSystems.add(_init);
+  }
+  
+  public boolean semaphore(final OSModel container, final Procedure1<? super Semaphore> initializer) {
+    EList<Semaphore> _semaphores = container.getSemaphores();
+    Semaphore _init = this.<Semaphore>init(AmaltheaFactory.eINSTANCE.createSemaphore(), initializer);
+    return _semaphores.add(_init);
+  }
+  
+  public boolean osOverhead(final OSModel container, final Procedure1<? super OsInstructions> initializer) {
+    EList<OsInstructions> _osOverheads = container.getOsOverheads();
+    OsInstructions _init = this.<OsInstructions>init(AmaltheaFactory.eINSTANCE.createOsInstructions(), initializer);
+    return _osOverheads.add(_init);
+  }
+  
+  public boolean taskScheduler(final OperatingSystem container, final Procedure1<? super TaskScheduler> initializer) {
+    EList<TaskScheduler> _taskSchedulers = container.getTaskSchedulers();
+    TaskScheduler _init = this.<TaskScheduler>init(AmaltheaFactory.eINSTANCE.createTaskScheduler(), initializer);
+    return _taskSchedulers.add(_init);
+  }
+  
+  public boolean interruptController(final OperatingSystem container, final Procedure1<? super InterruptController> initializer) {
+    EList<InterruptController> _interruptControllers = container.getInterruptControllers();
+    InterruptController _init = this.<InterruptController>init(AmaltheaFactory.eINSTANCE.createInterruptController(), initializer);
+    return _interruptControllers.add(_init);
+  }
+  
+  public void dataConsistency(final OperatingSystem container, final Procedure1<? super OsDataConsistency> initializer) {
+    container.setOsDataConsistency(this.<OsDataConsistency>init(AmaltheaFactory.eINSTANCE.createOsDataConsistency(), initializer));
+  }
+  
+  public boolean labelAccess(final Scheduler container, final Procedure1<? super LabelAccess> initializer) {
+    EList<ComputationItem> _computationItems = container.getComputationItems();
+    LabelAccess _init = this.<LabelAccess>init(AmaltheaFactory.eINSTANCE.createLabelAccess(), initializer);
+    return _computationItems.add(_init);
+  }
+  
+  public void parentAssociation(final TaskScheduler container, final Procedure1<? super SchedulerAssociation> initializer) {
+    container.setParentAssociation(this.<SchedulerAssociation>init(AmaltheaFactory.eINSTANCE.createSchedulerAssociation(), initializer));
+  }
+  
+  public void schedulingParameters(final SchedulerAssociation container, final Procedure1<? super SchedulingParameters> initializer) {
+    container.setSchedulingParameters(this.<SchedulingParameters>init(AmaltheaFactory.eINSTANCE.createSchedulingParameters(), initializer));
+  }
+  
+  public String parameter_extension(final SchedulerAssociation container, final String key, final String value) {
+    return container.getParameterExtensions().put(key, value);
+  }
+  
+  public void apiOverhead(final OsInstructions container, final Procedure1<? super OsAPIInstructions> initializer) {
+    container.setApiOverhead(this.<OsAPIInstructions>init(AmaltheaFactory.eINSTANCE.createOsAPIInstructions(), initializer));
+  }
+  
+  public void isrOverheadCat1(final OsInstructions container, final Procedure1<? super OsISRInstructions> initializer) {
+    container.setIsrCategory1Overhead(this.<OsISRInstructions>init(AmaltheaFactory.eINSTANCE.createOsISRInstructions(), initializer));
+  }
+  
+  public void isrOverheadCat2(final OsInstructions container, final Procedure1<? super OsISRInstructions> initializer) {
+    container.setIsrCategory2Overhead(this.<OsISRInstructions>init(AmaltheaFactory.eINSTANCE.createOsISRInstructions(), initializer));
+  }
+  
+  private <T extends Object> T init(final T obj, final Procedure1<? super T> init) {
+    init.apply(obj);
+    return obj;
+  }
+}
diff --git a/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/SoftwareBuilder.java b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/SoftwareBuilder.java
new file mode 100644
index 0000000..ea0ab20
--- /dev/null
+++ b/plugins/org.eclipse.app4mc.amalthea.model/xtend-gen/org/eclipse/app4mc/amalthea/model/builder/SoftwareBuilder.java
@@ -0,0 +1,312 @@
+package org.eclipse.app4mc.amalthea.model.builder;
+
+import org.eclipse.app4mc.amalthea.model.Activation;
+import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
+import org.eclipse.app4mc.amalthea.model.Channel;
+import org.eclipse.app4mc.amalthea.model.CustomActivation;
+import org.eclipse.app4mc.amalthea.model.EventActivation;
+import org.eclipse.app4mc.amalthea.model.Group;
+import org.eclipse.app4mc.amalthea.model.ISR;
+import org.eclipse.app4mc.amalthea.model.Label;
+import org.eclipse.app4mc.amalthea.model.LabelAccess;
+import org.eclipse.app4mc.amalthea.model.Mode;
+import org.eclipse.app4mc.amalthea.model.ModeLabel;
+import org.eclipse.app4mc.amalthea.model.ModeLiteral;
+import org.eclipse.app4mc.amalthea.model.ModeSwitchDefault;
+import org.eclipse.app4mc.amalthea.model.ModeSwitchEntry;
+import org.eclipse.app4mc.amalthea.model.PeriodicActivation;
+import org.eclipse.app4mc.amalthea.model.ProbabilitySwitchEntry;
+import org.eclipse.app4mc.amalthea.model.ProcessPrototype;
+import org.eclipse.app4mc.amalthea.model.RunnableCall;
+import org.eclipse.app4mc.amalthea.model.RunnableItem;
+import org.eclipse.app4mc.amalthea.model.RunnableModeSwitch;
+import org.eclipse.app4mc.amalthea.model.RunnableParameter;
+import org.eclipse.app4mc.amalthea.model.RunnableProbabilitySwitch;
+import org.eclipse.app4mc.amalthea.model.SWModel;
+import org.eclipse.app4mc.amalthea.model.Section;
+import org.eclipse.app4mc.amalthea.model.SingleActivation;
+import org.eclipse.app4mc.amalthea.model.SporadicActivation;
+import org.eclipse.app4mc.amalthea.model.Task;
+import org.eclipse.app4mc.amalthea.model.VariableRateActivation;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
+
+@SuppressWarnings("all")
+public class SoftwareBuilder {
+  public SWModel softwareModelRoot(final Procedure1<? super SWModel> initializer) {
+    return this.<SWModel>init(AmaltheaFactory.eINSTANCE.createSWModel(), initializer);
+  }
+  
+  public boolean isr(final SWModel container, final Procedure1<? super ISR> initializer) {
+    EList<ISR> _isrs = container.getIsrs();
+    ISR _init = this.<ISR>init(AmaltheaFactory.eINSTANCE.createISR(), initializer);
+    return _isrs.add(_init);
+  }
+  
+  public boolean task(final SWModel container, final Procedure1<? super Task> initializer) {
+    EList<Task> _tasks = container.getTasks();
+    Task _init = this.<Task>init(AmaltheaFactory.eINSTANCE.createTask(), initializer);
+    return _tasks.add(_init);
+  }
+  
+  public boolean runnable(final SWModel container, final Procedure1<? super org.eclipse.app4mc.amalthea.model.Runnable> initializer) {
+    EList<org.eclipse.app4mc.amalthea.model.Runnable> _runnables = container.getRunnables();
+    org.eclipse.app4mc.amalthea.model.Runnable _init = this.<org.eclipse.app4mc.amalthea.model.Runnable>init(AmaltheaFactory.eINSTANCE.createRunnable(), initializer);
+    return _runnables.add(_init);
+  }
+  
+  public boolean label(final SWModel container, final Procedure1<? super Label> initializer) {
+    EList<Label> _labels = container.getLabels();
+    Label _init = this.<Label>init(AmaltheaFactory.eINSTANCE.createLabel(), initializer);
+    return _labels.add(_init);
+  }
+  
+  public boolean channel(final SWModel container, final Procedure1<? super Channel> initializer) {
+    EList<Channel> _channels = container.getChannels();
+    Channel _init = this.<Channel>init(AmaltheaFactory.eINSTANCE.createChannel(), initializer);
+    return _channels.add(_init);
+  }
+  
+  public boolean processPrototype(final SWModel container, final Procedure1<? super ProcessPrototype> initializer) {
+    EList<ProcessPrototype> _processPrototypes = container.getProcessPrototypes();
+    ProcessPrototype _init = this.<ProcessPrototype>init(AmaltheaFactory.eINSTANCE.createProcessPrototype(), initializer);
+    return _processPrototypes.add(_init);
+  }
+  
+  public boolean section(final SWModel container, final Procedure1<? super Section> initializer) {
+    EList<Section> _sections = container.getSections();
+    Section _init = this.<Section>init(AmaltheaFactory.eINSTANCE.createSection(), initializer);
+    return _sections.add(_init);
+  }
+  
+  public boolean activation_Single(final SWModel container, final Procedure1<? super SingleActivation> initializer) {
+    EList<Activation> _activations = container.getActivations();
+    SingleActivation _init = this.<SingleActivation>init(AmaltheaFactory.eINSTANCE.createSingleActivation(), initializer);
+    return _activations.add(_init);
+  }
+  
+  public boolean activation_Sporadic(final SWModel container, final Procedure1<? super SporadicActivation> initializer) {
+    EList<Activation> _activations = container.getActivations();
+    SporadicActivation _init = this.<SporadicActivation>init(AmaltheaFactory.eINSTANCE.createSporadicActivation(), initializer);
+    return _activations.add(_init);
+  }
+  
+  public boolean activation_Periodic(final SWModel container, final Procedure1<? super PeriodicActivation> initializer) {
+    EList<Activation> _activations = container.getActivations();
+    PeriodicActivation _init = this.<PeriodicActivation>init(AmaltheaFactory.eINSTANCE.createPeriodicActivation(), initializer);
+    return _activations.add(_init);
+  }
+  
+  public boolean activation_Event(final SWModel container, final Procedure1<? super EventActivation> initializer) {
+    EList<Activation> _activations = container.getActivations();
+    EventActivation _init = this.<EventActivation>init(AmaltheaFactory.eINSTANCE.createEventActivation(), initializer);
+    return _activations.add(_init);
+  }
+  
+  public boolean activation_VariableRate(final SWModel container, final Procedure1<? super VariableRateActivation> initializer) {
+    EList<Activation> _activations = container.getActivations();
+    VariableRateActivation _init = this.<VariableRateActivation>init(AmaltheaFactory.eINSTANCE.createVariableRateActivation(), initializer);
+    return _activations.add(_init);
+  }
+  
+  public boolean activation_Custom(final SWModel container, final Procedure1<? super CustomActivation> initializer) {
+    EList<Activation> _activations = container.getActivations();
+    CustomActivation _init = this.<CustomActivation>init(AmaltheaFactory.eINSTANCE.createCustomActivation(), initializer);
+    return _activations.add(_init);
+  }
+  
+  public boolean mode(final SWModel container, final Procedure1<? super Mode> initializer) {
+    EList<Mode> _modes = container.getModes();
+    Mode _init = this.<Mode>init(AmaltheaFactory.eINSTANCE.createMode(), initializer);
+    return _modes.add(_init);
+  }
+  
+  public boolean modeLabel(final SWModel container, final Procedure1<? super ModeLabel> initializer) {
+    EList<ModeLabel> _modeLabels = container.getModeLabels();
+    ModeLabel _init = this.<ModeLabel>init(AmaltheaFactory.eINSTANCE.createModeLabel(), initializer);
+    return _modeLabels.add(_init);
+  }
+  
+  public boolean literal(final Mode container, final Procedure1<? super ModeLiteral> initializer) {
+    EList<ModeLiteral> _literals = container.getLiterals();
+    ModeLiteral _init = this.<ModeLiteral>init(AmaltheaFactory.eINSTANCE.createModeLiteral(), initializer);
+    return _literals.add(_init);
+  }
+  
+  public boolean parameter(final org.eclipse.app4mc.amalthea.model.Runnable container, final Procedure1<? super RunnableParameter> initializer) {
+    EList<RunnableParameter> _parameters = container.getParameters();
+    RunnableParameter _init = this.<RunnableParameter>init(AmaltheaFactory.eINSTANCE.createRunnableParameter(), initializer);
+    return _parameters.add(_init);
+  }
+  
+  public boolean group(final org.eclipse.app4mc.amalthea.model.Runnable container, final Procedure1<? super Group> initializer) {
+    EList<RunnableItem> _runnableItems = container.getRunnableItems();
+    Group _init = this.<Group>init(AmaltheaFactory.eINSTANCE.createGroup(), initializer);
+    return _runnableItems.add(_init);
+  }
+  
+  public boolean group(final Group container, final Procedure1<? super Group> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    Group _init = this.<Group>init(AmaltheaFactory.eINSTANCE.createGroup(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean group(final ModeSwitchDefault<RunnableItem> container, final Procedure1<? super Group> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    Group _init = this.<Group>init(AmaltheaFactory.eINSTANCE.createGroup(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean group(final ModeSwitchEntry<RunnableItem> container, final Procedure1<? super Group> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    Group _init = this.<Group>init(AmaltheaFactory.eINSTANCE.createGroup(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean group(final ProbabilitySwitchEntry<RunnableItem> container, final Procedure1<? super Group> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    Group _init = this.<Group>init(AmaltheaFactory.eINSTANCE.createGroup(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean modeSwitch(final org.eclipse.app4mc.amalthea.model.Runnable container, final Procedure1<? super RunnableModeSwitch> initializer) {
+    EList<RunnableItem> _runnableItems = container.getRunnableItems();
+    RunnableModeSwitch _init = this.<RunnableModeSwitch>init(AmaltheaFactory.eINSTANCE.createRunnableModeSwitch(), initializer);
+    return _runnableItems.add(_init);
+  }
+  
+  public boolean modeSwitch(final Group container, final Procedure1<? super RunnableModeSwitch> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    RunnableModeSwitch _init = this.<RunnableModeSwitch>init(AmaltheaFactory.eINSTANCE.createRunnableModeSwitch(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean modeSwitch(final ModeSwitchDefault<RunnableItem> container, final Procedure1<? super RunnableModeSwitch> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    RunnableModeSwitch _init = this.<RunnableModeSwitch>init(AmaltheaFactory.eINSTANCE.createRunnableModeSwitch(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean modeSwitch(final ModeSwitchEntry<RunnableItem> container, final Procedure1<? super RunnableModeSwitch> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    RunnableModeSwitch _init = this.<RunnableModeSwitch>init(AmaltheaFactory.eINSTANCE.createRunnableModeSwitch(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean modeSwitch(final ProbabilitySwitchEntry<RunnableItem> container, final Procedure1<? super RunnableModeSwitch> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    RunnableModeSwitch _init = this.<RunnableModeSwitch>init(AmaltheaFactory.eINSTANCE.createRunnableModeSwitch(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean entry(final RunnableModeSwitch container, final Procedure1<? super ModeSwitchEntry<RunnableItem>> initializer) {
+    EList<ModeSwitchEntry<RunnableItem>> _entries = container.getEntries();
+    ModeSwitchEntry<RunnableItem> _init = this.<ModeSwitchEntry<RunnableItem>>init(AmaltheaFactory.eINSTANCE.<RunnableItem>createModeSwitchEntry(), initializer);
+    return _entries.add(_init);
+  }
+  
+  public void defaultEntry(final RunnableModeSwitch container, final Procedure1<? super ModeSwitchDefault<RunnableItem>> initializer) {
+    container.setDefaultEntry(this.<ModeSwitchDefault<RunnableItem>>init(AmaltheaFactory.eINSTANCE.<RunnableItem>createModeSwitchDefault(), initializer));
+  }
+  
+  public boolean probabilitySwitch(final org.eclipse.app4mc.amalthea.model.Runnable container, final Procedure1<? super RunnableProbabilitySwitch> initializer) {
+    EList<RunnableItem> _runnableItems = container.getRunnableItems();
+    RunnableProbabilitySwitch _init = this.<RunnableProbabilitySwitch>init(AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch(), initializer);
+    return _runnableItems.add(_init);
+  }
+  
+  public boolean probabilitySwitch(final Group container, final Procedure1<? super RunnableProbabilitySwitch> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    RunnableProbabilitySwitch _init = this.<RunnableProbabilitySwitch>init(AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean probabilitySwitch(final ModeSwitchDefault<RunnableItem> container, final Procedure1<? super RunnableProbabilitySwitch> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    RunnableProbabilitySwitch _init = this.<RunnableProbabilitySwitch>init(AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean probabilitySwitch(final ModeSwitchEntry<RunnableItem> container, final Procedure1<? super RunnableProbabilitySwitch> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    RunnableProbabilitySwitch _init = this.<RunnableProbabilitySwitch>init(AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean probabilitySwitch(final ProbabilitySwitchEntry<RunnableItem> container, final Procedure1<? super RunnableProbabilitySwitch> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    RunnableProbabilitySwitch _init = this.<RunnableProbabilitySwitch>init(AmaltheaFactory.eINSTANCE.createRunnableProbabilitySwitch(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean entry(final RunnableProbabilitySwitch container, final Procedure1<? super ProbabilitySwitchEntry<RunnableItem>> initializer) {
+    EList<ProbabilitySwitchEntry<RunnableItem>> _entries = container.getEntries();
+    ProbabilitySwitchEntry<RunnableItem> _init = this.<ProbabilitySwitchEntry<RunnableItem>>init(AmaltheaFactory.eINSTANCE.<RunnableItem>createProbabilitySwitchEntry(), initializer);
+    return _entries.add(_init);
+  }
+  
+  public boolean labelAccess(final org.eclipse.app4mc.amalthea.model.Runnable container, final Procedure1<? super LabelAccess> initializer) {
+    EList<RunnableItem> _runnableItems = container.getRunnableItems();
+    LabelAccess _init = this.<LabelAccess>init(AmaltheaFactory.eINSTANCE.createLabelAccess(), initializer);
+    return _runnableItems.add(_init);
+  }
+  
+  public boolean labelAccess(final Group container, final Procedure1<? super LabelAccess> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    LabelAccess _init = this.<LabelAccess>init(AmaltheaFactory.eINSTANCE.createLabelAccess(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean labelAccess(final ModeSwitchDefault<RunnableItem> container, final Procedure1<? super LabelAccess> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    LabelAccess _init = this.<LabelAccess>init(AmaltheaFactory.eINSTANCE.createLabelAccess(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean labelAccess(final ModeSwitchEntry<RunnableItem> container, final Procedure1<? super LabelAccess> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    LabelAccess _init = this.<LabelAccess>init(AmaltheaFactory.eINSTANCE.createLabelAccess(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean labelAccess(final ProbabilitySwitchEntry<RunnableItem> container, final Procedure1<? super LabelAccess> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    LabelAccess _init = this.<LabelAccess>init(AmaltheaFactory.eINSTANCE.createLabelAccess(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean runnableCall(final org.eclipse.app4mc.amalthea.model.Runnable container, final Procedure1<? super RunnableCall> initializer) {
+    EList<RunnableItem> _runnableItems = container.getRunnableItems();
+    RunnableCall _init = this.<RunnableCall>init(AmaltheaFactory.eINSTANCE.createRunnableCall(), initializer);
+    return _runnableItems.add(_init);
+  }
+  
+  public boolean runnableCall(final Group container, final Procedure1<? super RunnableCall> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    RunnableCall _init = this.<RunnableCall>init(AmaltheaFactory.eINSTANCE.createRunnableCall(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean runnableCall(final ModeSwitchDefault<RunnableItem> container, final Procedure1<? super RunnableCall> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    RunnableCall _init = this.<RunnableCall>init(AmaltheaFactory.eINSTANCE.createRunnableCall(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean runnableCall(final ModeSwitchEntry<RunnableItem> container, final Procedure1<? super RunnableCall> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    RunnableCall _init = this.<RunnableCall>init(AmaltheaFactory.eINSTANCE.createRunnableCall(), initializer);
+    return _items.add(_init);
+  }
+  
+  public boolean runnableCall(final ProbabilitySwitchEntry<RunnableItem> container, final Procedure1<? super RunnableCall> initializer) {
+    EList<RunnableItem> _items = container.getItems();
+    RunnableCall _init = this.<RunnableCall>init(AmaltheaFactory.eINSTANCE.createRunnableCall(), initializer);
+    return _items.add(_init);
+  }
+  
+  private <T extends Object> T init(final T obj, final Procedure1<? super T> init) {
+    init.apply(obj);
+    return obj;
+  }
+}