diff --git a/.idea/.idea.linuxdistrosbuttheyarebreedable/.idea/workspace.xml b/.idea/.idea.linuxdistrosbuttheyarebreedable/.idea/workspace.xml
index 3b18826..889bf0a 100644
--- a/.idea/.idea.linuxdistrosbuttheyarebreedable/.idea/workspace.xml
+++ b/.idea/.idea.linuxdistrosbuttheyarebreedable/.idea/workspace.xml
@@ -11,10 +11,37 @@
   </component>
   <component name="ChangeListManager">
     <list default="true" id="4222a6b8-add3-4f43-9c42-fd6bb5a76169" name="Changes" comment="">
+      <change afterPath="$PROJECT_DIR$/Assets/Data/Cards/Languages/C/Malloc.asset" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/Assets/Data/Cards/Languages/C/Pointer.asset" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/Assets/Data/Cards/Languages/C/Printf.asset" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/Assets/Data/Cards/Languages/CDeck.asset" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/Assets/Data/Cards/Shop/Free.asset" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/Assets/Data/Cards/Shop/KernelExploit.asset" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/Assets/Data/Cards/Shop/Sizeof.asset" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/Assets/Data/Distros/Arch.asset" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/Assets/Data/Distros/Art/arch.txt" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/Assets/Data/Distros/Art/arch.txt.meta" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/Assets/Data/Packages/Aur.asset" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/Assets/Data/Packages/Systemd.asset" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/Assets/Data/Passives/IUseArchBtw.asset" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/.idea/.idea.linuxdistrosbuttheyarebreedable/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/.idea.linuxdistrosbuttheyarebreedable/.idea/workspace.xml" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Data/Cards/CardDatabase.asset" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Data/Cards/CardDatabase.asset" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Data/Cards/Languages/LanguageDeckDatabase.asset" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Data/Cards/Languages/LanguageDeckDatabase.asset" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Data/Distros/DistroDatabase.asset" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Data/Distros/DistroDatabase.asset" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Data/Packages/PackageDatabase.asset" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Data/Packages/PackageDatabase.asset" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Scripts/Combat/CardEffects.cs" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Scripts/Combat/CardEffects.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Scripts/Combat/CombatManager.cs" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Scripts/Combat/CombatManager.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Scripts/Combat/CombatantState.cs" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Scripts/Combat/CombatantState.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Scripts/Combat/DamagePipeline.cs" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Scripts/Combat/DamagePipeline.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Scripts/Data/PackageDefinition.cs" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Scripts/Data/PackageDefinition.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Scripts/Meta/DistroVersionCatalog.cs" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Scripts/Meta/DistroVersionCatalog.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Scripts/Meta/GachaService.cs" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Scripts/Meta/GachaService.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/Assets/Scripts/Run/RunManager.cs" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Scripts/Run/RunManager.cs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/Assets/Scripts/UI/CollectionScreenController.cs" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Scripts/UI/CollectionScreenController.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/Assets/UI/MainMenu.uss" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/UI/MainMenu.uss" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Scripts/UI/GachaScreenController.cs" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Scripts/UI/GachaScreenController.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Scripts/UI/GamblingSceneController.cs" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Scripts/UI/GamblingSceneController.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Scripts/UI/MainMenuController.cs" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Scripts/UI/MainMenuController.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/Assets/Scripts/UI/StarterSelectionController.cs" beforeDir="false" afterPath="$PROJECT_DIR$/Assets/Scripts/UI/StarterSelectionController.cs" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -49,6 +76,7 @@
     <setting file="file://$PROJECT_DIR$/Assets/Data/Cards/Fedora/BorrowChecker.asset" root0="FORCE_HIGHLIGHTING" />
     <setting file="file://$PROJECT_DIR$/Assets/Data/Cards/Fedora/CargoBuildRelease.asset" root0="FORCE_HIGHLIGHTING" />
     <setting file="file://$PROJECT_DIR$/Assets/Data/Cards/Fedora/DnfUpdate.asset" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$PROJECT_DIR$/Assets/Data/Cards/Languages/C/Malloc.asset" root0="FORCE_HIGHLIGHTING" />
     <setting file="file://$PROJECT_DIR$/Assets/Data/Cards/Languages/Java/JavaPublicStaticMain.asset" root0="FORCE_HIGHLIGHTING" />
     <setting file="file://$PROJECT_DIR$/Assets/Data/Cards/Languages/Java/JavaSystemOutPrintln.asset" root0="FORCE_HIGHLIGHTING" />
     <setting file="file://$PROJECT_DIR$/Assets/Data/Cards/Languages/Python/PyPrint.asset" root0="FORCE_HIGHLIGHTING" />
@@ -90,23 +118,23 @@
   <component name="MetaFilesCheckinStateConfiguration" checkMetaFiles="true" />
   <component name="NextEditCompletionFeaturesState">
     <decayedCancelled>
-      <entry key="MS100" value="1.303475344688572" />
-      <entry key="MS500" value="5.3926656022419355" />
-      <entry key="S2" value="20.294425547037598" />
-      <entry key="S5" value="46.02472779650448" />
-      <entry key="S10" value="75.10224826080193" />
-      <entry key="S30" value="116.756386597024" />
-      <entry key="S60" value="132.70480982869236" />
-      <entry key="M2" value="141.9955165492664" />
-      <entry key="M5" value="157.16923502238322" />
-      <entry key="M10" value="192.65306177401038" />
-      <entry key="M15" value="222.3537750260655" />
-      <entry key="M30" value="272.70669556712824" />
-      <entry key="H1" value="314.3552276126616" />
-      <entry key="H2" value="408.28563599020407" />
-      <entry key="H4" value="741.98755653759" />
-      <entry key="D1" value="2977.3514394521176" />
-      <entry key="W1" value="4961.511940764881" />
+      <entry key="MS100" value="1.1040497809107481" />
+      <entry key="MS500" value="3.714798159570809" />
+      <entry key="S2" value="11.68860568898124" />
+      <entry key="S5" value="20.10530350052927" />
+      <entry key="S10" value="26.13933097157673" />
+      <entry key="S30" value="32.13507287696936" />
+      <entry key="S60" value="34.35034847825896" />
+      <entry key="M2" value="41.829650528743535" />
+      <entry key="M5" value="82.9519319589652" />
+      <entry key="M10" value="147.82939685711494" />
+      <entry key="M15" value="193.49123741346352" />
+      <entry key="M30" value="274.2846911461227" />
+      <entry key="H1" value="385.98935725422314" />
+      <entry key="H2" value="566.2873520605849" />
+      <entry key="H4" value="919.4750522788173" />
+      <entry key="D1" value="3279.123798476327" />
+      <entry key="W1" value="5478.811080497626" />
     </decayedCancelled>
     <decayedSelected>
       <entry key="MS100" value="0.0" />
@@ -116,35 +144,35 @@
       <entry key="S10" value="0.0" />
       <entry key="S30" value="0.0" />
       <entry key="S60" value="0.0" />
-      <entry key="M2" value="3.0E-323" />
-      <entry key="M5" value="9.244545133631687E-130" />
-      <entry key="M10" value="3.0404843583929786E-65" />
-      <entry key="M15" value="9.74156013306164E-44" />
-      <entry key="M30" value="3.121148251945742E-22" />
-      <entry key="H1" value="1.7684137325623194E-11" />
-      <entry key="H2" value="4.431447925314597E-6" />
-      <entry key="H4" value="0.0028776829122893056" />
-      <entry key="D1" value="1.1218371428837055" />
-      <entry key="W1" value="3.3311376701614477" />
+      <entry key="M2" value="0.0" />
+      <entry key="M5" value="1.5957500715172193E-141" />
+      <entry key="M10" value="3.994684056990454E-71" />
+      <entry key="M15" value="1.1685706048432312E-47" />
+      <entry key="M30" value="3.418437300700796E-24" />
+      <entry key="H1" value="1.850719023980869E-12" />
+      <entry key="H2" value="1.4335866743543608E-6" />
+      <entry key="H4" value="0.0016367490238057612" />
+      <entry key="D1" value="1.0211424728874252" />
+      <entry key="W1" value="3.2866828573220803" />
     </decayedSelected>
     <decayedShown>
-      <entry key="MS100" value="1.2566545459762934" />
-      <entry key="MS500" value="5.351173370423456" />
-      <entry key="S2" value="20.255413709804333" />
-      <entry key="S5" value="45.988601609033005" />
-      <entry key="S10" value="75.07245405372439" />
-      <entry key="S30" value="116.74083732450484" />
-      <entry key="S60" value="132.69595850502105" />
-      <entry key="M2" value="141.99077691444745" />
-      <entry key="M5" value="157.16712437698786" />
-      <entry key="M10" value="192.65174658978927" />
-      <entry key="M15" value="222.35275187576812" />
-      <entry key="M30" value="272.7060572994754" />
-      <entry key="H1" value="314.3548323813724" />
-      <entry key="H2" value="408.2853250098047" />
-      <entry key="H4" value="741.9901088328525" />
-      <entry key="D1" value="2978.472976582466" />
-      <entry key="W1" value="4964.842993847027" />
+      <entry key="MS100" value="1.050513762775976" />
+      <entry key="MS500" value="3.6754429047622104" />
+      <entry key="S2" value="11.65796718737336" />
+      <entry key="S5" value="20.084311060325582" />
+      <entry key="S10" value="26.125711482692548" />
+      <entry key="S30" value="32.12949996608303" />
+      <entry key="S60" value="34.34737056791278" />
+      <entry key="M2" value="41.827834097645756" />
+      <entry key="M5" value="82.95047510295649" />
+      <entry key="M10" value="147.82807658405247" />
+      <entry key="M15" value="193.49007535362955" />
+      <entry key="M30" value="274.283859325205" />
+      <entry key="H1" value="385.98877279131835" />
+      <entry key="H2" value="566.2869146370476" />
+      <entry key="H4" value="919.4763100903577" />
+      <entry key="D1" value="3280.1446307590936" />
+      <entry key="W1" value="5482.097674456233" />
     </decayedShown>
   </component>
   <component name="ProjectColorInfo">{
@@ -236,7 +264,7 @@
       <workItem from="1783410502976" duration="23430000" />
       <workItem from="1783507489679" duration="5909000" />
       <workItem from="1783519887449" duration="6425000" />
-      <workItem from="1783578446731" duration="14988000" />
+      <workItem from="1783578446731" duration="20078000" />
     </task>
     <task id="LOCAL-00001" summary="implement main screen">
       <option name="closed" value="true" />
@@ -446,7 +474,15 @@
       <option name="project" value="LOCAL" />
       <updated>1783585689781</updated>
     </task>
-    <option name="localTasksCounter" value="27" />
+    <task id="LOCAL-00027" summary="Make multiple UX improvements in distro -&gt; packages">
+      <option name="closed" value="true" />
+      <created>1783603850701</created>
+      <option name="number" value="00027" />
+      <option name="presentableId" value="LOCAL-00027" />
+      <option name="project" value="LOCAL" />
+      <updated>1783603850701</updated>
+    </task>
+    <option name="localTasksCounter" value="28" />
     <servers />
   </component>
   <component name="TypeScriptGeneratedFilesManager">
@@ -462,7 +498,6 @@
   <component name="UnityUnitTestConfiguration" currentTestLauncher="Both" />
   <component name="VcsManagerConfiguration">
     <option name="CLEAR_INITIAL_COMMIT_MESSAGE" value="true" />
-    <MESSAGE value="implement main screen" />
     <MESSAGE value="fix shit and stuff" />
     <MESSAGE value="Add actual ASCII-Art for distros, add first three distros and being able to choose a starting-distro. Update UI to fix multiple small bugs." />
     <MESSAGE value="refactor card systems" />
@@ -487,7 +522,8 @@
     <MESSAGE value="make small changes to design. Implement crits." />
     <MESSAGE value="Implement many UX improvements, packages and their assets and a UI overhaul in collection" />
     <MESSAGE value="restructure packages (it looks shit)" />
-    <option name="LAST_COMMIT_MESSAGE" value="restructure packages (it looks shit)" />
+    <MESSAGE value="Make multiple UX improvements in distro -&gt; packages" />
+    <option name="LAST_COMMIT_MESSAGE" value="Make multiple UX improvements in distro -&gt; packages" />
   </component>
   <component name="XDebuggerManager">
     <breakpoint-manager>
diff --git a/Assets/Data/Cards/CardDatabase.asset b/Assets/Data/Cards/CardDatabase.asset
index d00804e..f67f955 100644
--- a/Assets/Data/Cards/CardDatabase.asset
+++ b/Assets/Data/Cards/CardDatabase.asset
@@ -47,3 +47,14 @@ MonoBehaviour:
   - {fileID: 11400000, guid: a7d60000000000000000000000000004, type: 2}
   - {fileID: 11400000, guid: a7d60000000000000000000000000005, type: 2}
   - {fileID: 11400000, guid: a7d60000000000000000000000000006, type: 2}
+  - {fileID: 11400000, guid: aa110000000000000000000000000001, type: 2}
+  - {fileID: 11400000, guid: aa110000000000000000000000000002, type: 2}
+  - {fileID: 11400000, guid: aa110000000000000000000000000003, type: 2}
+  - {fileID: 11400000, guid: aa110000000000000000000000000004, type: 2}
+  - {fileID: 11400000, guid: aa110000000000000000000000000005, type: 2}
+  - {fileID: 11400000, guid: aa120000000000000000000000000001, type: 2}
+  - {fileID: 11400000, guid: aa120000000000000000000000000002, type: 2}
+  - {fileID: 11400000, guid: aa120000000000000000000000000003, type: 2}
+  - {fileID: 11400000, guid: aa120000000000000000000000000004, type: 2}
+  - {fileID: 11400000, guid: aa120000000000000000000000000005, type: 2}
+  - {fileID: 11400000, guid: aa120000000000000000000000000006, type: 2}
diff --git a/Assets/Data/Cards/Languages/C/Malloc.asset b/Assets/Data/Cards/Languages/C/Malloc.asset
new file mode 100644
index 0000000..c674d58
--- /dev/null
+++ b/Assets/Data/Cards/Languages/C/Malloc.asset
@@ -0,0 +1,29 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5178747fac4dbfc448ff15d8a687e03c, type: 3}
+  m_Name: Malloc
+  m_EditorClassIdentifier: 
+  id: lang_c_malloc
+  displayName: malloc()
+  description: deal 8. 20% segfault: take 3.
+  flavorText: memory acquired. ownership emotionally unresolved.
+  language: 0
+  rarity: 0
+  cycleCost: 1
+  resolutionTrack: 0
+  distroExclusive: 0
+  isToken: 0
+  isRunOnly: 0
+  designNotes: C starter. Segfault rolls through RandomRoll; damage and recoil route through DamagePipeline.
+  requiresSystem: []
+  upgradeTarget: {fileID: 0}
+  effects: []
diff --git a/Assets/Data/Cards/Languages/C/Pointer.asset b/Assets/Data/Cards/Languages/C/Pointer.asset
new file mode 100644
index 0000000..60782f6
--- /dev/null
+++ b/Assets/Data/Cards/Languages/C/Pointer.asset
@@ -0,0 +1,29 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5178747fac4dbfc448ff15d8a687e03c, type: 3}
+  m_Name: Pointer
+  m_EditorClassIdentifier: 
+  id: lang_c_pointer
+  displayName: pointer
+  description: deal 6. if the previous card was C, deal 10 instead.
+  flavorText: points at the bug with suspicious confidence.
+  language: 0
+  rarity: 0
+  cycleCost: 1
+  resolutionTrack: 0
+  distroExclusive: 0
+  isToken: 0
+  isRunOnly: 0
+  designNotes: C starter. Uses existing last-played-language tracking on CombatantState; damage routes through DamagePipeline.
+  requiresSystem: []
+  upgradeTarget: {fileID: 0}
+  effects: []
diff --git a/Assets/Data/Cards/Languages/C/Printf.asset b/Assets/Data/Cards/Languages/C/Printf.asset
new file mode 100644
index 0000000..a959fc3
--- /dev/null
+++ b/Assets/Data/Cards/Languages/C/Printf.asset
@@ -0,0 +1,29 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5178747fac4dbfc448ff15d8a687e03c, type: 3}
+  m_Name: Printf
+  m_EditorClassIdentifier: 
+  id: lang_c_printf
+  displayName: printf()
+  description: deal 4.
+  flavorText: debugging by yelling into the void.
+  language: 0
+  rarity: 0
+  cycleCost: 0
+  resolutionTrack: 0
+  distroExclusive: 0
+  isToken: 0
+  isRunOnly: 0
+  designNotes: C starter. Clean low-cost damage routed through DamagePipeline.
+  requiresSystem: []
+  upgradeTarget: {fileID: 0}
+  effects: []
diff --git a/Assets/Data/Cards/Languages/CDeck.asset b/Assets/Data/Cards/Languages/CDeck.asset
new file mode 100644
index 0000000..4e4f900
--- /dev/null
+++ b/Assets/Data/Cards/Languages/CDeck.asset
@@ -0,0 +1,22 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: a7d10000000000000000000000000001, type: 3}
+  m_Name: CDeck
+  m_EditorClassIdentifier: 
+  language: 0
+  entries:
+  - card: {fileID: 11400000, guid: aa120000000000000000000000000001, type: 2}
+    count: 2
+  - card: {fileID: 11400000, guid: aa120000000000000000000000000002, type: 2}
+    count: 1
+  - card: {fileID: 11400000, guid: aa120000000000000000000000000003, type: 2}
+    count: 1
diff --git a/Assets/Data/Cards/Languages/LanguageDeckDatabase.asset b/Assets/Data/Cards/Languages/LanguageDeckDatabase.asset
index f0a40a4..3daf150 100644
--- a/Assets/Data/Cards/Languages/LanguageDeckDatabase.asset
+++ b/Assets/Data/Cards/Languages/LanguageDeckDatabase.asset
@@ -17,3 +17,4 @@ MonoBehaviour:
   - {fileID: 11400000, guid: a7d50000000000000000000000000002, type: 2}
   - {fileID: 11400000, guid: a7d70000000000000000000000000001, type: 2}
   - {fileID: 11400000, guid: a7d70000000000000000000000000002, type: 2}
+  - {fileID: 11400000, guid: aa130000000000000000000000000001, type: 2}
diff --git a/Assets/Data/Cards/Shop/Free.asset b/Assets/Data/Cards/Shop/Free.asset
new file mode 100644
index 0000000..6eda7de
--- /dev/null
+++ b/Assets/Data/Cards/Shop/Free.asset
@@ -0,0 +1,29 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5178747fac4dbfc448ff15d8a687e03c, type: 3}
+  m_Name: Free
+  m_EditorClassIdentifier: 
+  id: shop_c_free
+  displayName: free()
+  description: deal 12. if segfault recoil happens, draw 2.
+  flavorText: double-free your schedule, not your heap.
+  language: 0
+  rarity: 0
+  cycleCost: 2
+  resolutionTrack: 0
+  distroExclusive: 0
+  isToken: 0
+  isRunOnly: 1
+  designNotes: C run-only shop card. Uses segfault recoil hook through RandomRoll and DamagePipeline; draw uses existing draw pipeline.
+  requiresSystem: []
+  upgradeTarget: {fileID: 0}
+  effects: []
diff --git a/Assets/Data/Cards/Shop/KernelExploit.asset b/Assets/Data/Cards/Shop/KernelExploit.asset
new file mode 100644
index 0000000..373691d
--- /dev/null
+++ b/Assets/Data/Cards/Shop/KernelExploit.asset
@@ -0,0 +1,29 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5178747fac4dbfc448ff15d8a687e03c, type: 3}
+  m_Name: KernelExploit
+  m_EditorClassIdentifier: 
+  id: shop_c_kernel_exploit
+  displayName: kernel_exploit
+  description: deal 25 ignoring Shield. 50% segfault: take 8.
+  flavorText: privilege escalated. heartbeat also escalated.
+  language: 0
+  rarity: 1
+  cycleCost: 3
+  resolutionTrack: 0
+  distroExclusive: 0
+  isToken: 0
+  isRunOnly: 1
+  designNotes: C run-only shop card. Ignore-Shield damage uses the true-damage pipeline flag; segfault recoil uses RandomRoll and DamagePipeline.
+  requiresSystem: []
+  upgradeTarget: {fileID: 0}
+  effects: []
diff --git a/Assets/Data/Cards/Shop/Sizeof.asset b/Assets/Data/Cards/Shop/Sizeof.asset
new file mode 100644
index 0000000..e56ced4
--- /dev/null
+++ b/Assets/Data/Cards/Shop/Sizeof.asset
@@ -0,0 +1,29 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5178747fac4dbfc448ff15d8a687e03c, type: 3}
+  m_Name: Sizeof
+  m_EditorClassIdentifier: 
+  id: shop_c_sizeof
+  displayName: sizeof()
+  description: deal 3 x C cards in hand.
+  flavorText: compile-time confidence, runtime consequences.
+  language: 0
+  rarity: 1
+  cycleCost: 1
+  resolutionTrack: 0
+  distroExclusive: 0
+  isToken: 0
+  isRunOnly: 1
+  designNotes: C run-only shop card. Counts current C cards in hand and deals through DamagePipeline.
+  requiresSystem: []
+  upgradeTarget: {fileID: 0}
+  effects: []
diff --git a/Assets/Data/Distros/Arch.asset b/Assets/Data/Distros/Arch.asset
new file mode 100644
index 0000000..19c4ab0
--- /dev/null
+++ b/Assets/Data/Distros/Arch.asset
@@ -0,0 +1,37 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: bd550368fd0c75d43a53aa4fb3b6541e, type: 3}
+  m_Name: Arch
+  m_EditorClassIdentifier: 
+  id: arch
+  displayName: Arch
+  primaryLanguage: 0
+  secondaryLanguage: 2
+  passive: {fileID: 11400000, guid: aa100000000000000000000000000001, type: 2}
+  description: The DIY power-user. Maximum control, maximum fragility. She can do things no one else can - and break herself doing it.
+  playstyleSummary: volatile C/Rust tempo. every played card adds btw, which makes C and Rust hits bigger until the turn ends.
+  languageBlurbs:
+  - lang: 0
+    blurb: sharp native damage with a higher crit rate and occasional segfault recoil.
+  - lang: 2
+    blurb: reliable native damage; overkill converts into shield.
+  asciiArt: {fileID: 4900000, guid: 004c732ec64a45fd82c5a47ae7ffed43, type: 3}
+  accentColor: {r: 0.09019608, g: 0.5764706, b: 0.81960785, a: 1}
+  baseUptime: 50
+  baseRam: 6
+  baseCyclesPerTurn: 4
+  exclusiveCards:
+  - {fileID: 11400000, guid: aa110000000000000000000000000001, type: 2}
+  - {fileID: 11400000, guid: aa110000000000000000000000000002, type: 2}
+  - {fileID: 11400000, guid: aa110000000000000000000000000003, type: 2}
+  - {fileID: 11400000, guid: aa110000000000000000000000000004, type: 2}
+  - {fileID: 11400000, guid: aa110000000000000000000000000005, type: 2}
diff --git a/Assets/Data/Distros/Art/arch.txt b/Assets/Data/Distros/Art/arch.txt
new file mode 100644
index 0000000..0960f0e
--- /dev/null
+++ b/Assets/Data/Distros/Art/arch.txt
@@ -0,0 +1,16 @@
+                              
+              ++              
+             ++++             
+            +++++=            
+           +++++++=           
+           + ++++++=          
+          ====+++++++         
+         ==========+++        
+        ==++++++++++++        
+       +++++++  +++++++       
+      ++++++      ++++++      
+     +++++++      +++++++     
+    ++++++++      +++++++     
+   +++++++          +++++++   
+  +++                    +++  
+ +                          + 
diff --git a/Assets/Data/Distros/Art/arch.txt.meta b/Assets/Data/Distros/Art/arch.txt.meta
new file mode 100644
index 0000000..ffd72b7
--- /dev/null
+++ b/Assets/Data/Distros/Art/arch.txt.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 004c732ec64a45fd82c5a47ae7ffed43
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Data/Distros/DistroDatabase.asset b/Assets/Data/Distros/DistroDatabase.asset
index a8d085e..c52244a 100644
--- a/Assets/Data/Distros/DistroDatabase.asset
+++ b/Assets/Data/Distros/DistroDatabase.asset
@@ -16,3 +16,4 @@ MonoBehaviour:
   - {fileID: 11400000, guid: 1b0892a0d4c34b03a54c3d511ae59356, type: 2}
   - {fileID: 11400000, guid: 245dfb73afe047d5a3a3ef54c30d5135, type: 2}
   - {fileID: 11400000, guid: 366e71361387449abcfaa1a50c9af87b, type: 2}
+  - {fileID: 11400000, guid: aa101000000000000000000000000001, type: 2}
diff --git a/Assets/Data/Packages/Aur.asset b/Assets/Data/Packages/Aur.asset
new file mode 100644
index 0000000..c687ab4
--- /dev/null
+++ b/Assets/Data/Packages/Aur.asset
@@ -0,0 +1,26 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 48447d3db18343398488d3064324147d, type: 3}
+  m_Name: Aur
+  m_EditorClassIdentifier: 
+  id: pkg_aur
+  displayName: AUR
+  slot: 1
+  rarity: 4
+  description: start each TURN with a generated C/Rust card. on Arch, any rarity and costs 1 less this turn; off-distro, common only with no discount.
+  flavourText: probably maintained by one person and a shell script named pls-work.sh.
+  designNotes: Arch 4-star Runtime package. Scope TURN. On Arch: generate random C/Rust card up to Legendary rarity and apply -1 temporary cost. Off-distro: generate Common C/Rust only with no discount. Uses existing generated-card pool; requiresSystem card-generation if no eligible pool is available. Runtime slot intentionally does not conflict with systemd Daemon.
+  intendedDistroId: arch
+  requiresSystem:
+  - card-generation
+  offDistroEffect: {kind: 26, amount: 0, threshold: 0, refundCycle: 0, cleanseDebuffs: 0, enableFedoraSecondCardPassive: 0, persistArchBtw: 0}
+  onDistroEffect: {kind: 26, amount: 1, threshold: 3, refundCycle: 0, cleanseDebuffs: 0, enableFedoraSecondCardPassive: 0, persistArchBtw: 0}
diff --git a/Assets/Data/Packages/PackageDatabase.asset b/Assets/Data/Packages/PackageDatabase.asset
index ae55c67..47db632 100644
--- a/Assets/Data/Packages/PackageDatabase.asset
+++ b/Assets/Data/Packages/PackageDatabase.asset
@@ -44,3 +44,5 @@ MonoBehaviour:
   - {fileID: 11400000, guid: 159fca0abb7249e1be485aaac5f83fbe, type: 2}
   - {fileID: 11400000, guid: ac481beaf7e6453d82a439d54c2fb2f3, type: 2}
   - {fileID: 11400000, guid: a8e4cfd86f554fa19198551a7d5ed8ab, type: 2}
+  - {fileID: 11400000, guid: aa140000000000000000000000000001, type: 2}
+  - {fileID: 11400000, guid: aa140000000000000000000000000002, type: 2}
diff --git a/Assets/Data/Packages/Systemd.asset b/Assets/Data/Packages/Systemd.asset
new file mode 100644
index 0000000..76203a7
--- /dev/null
+++ b/Assets/Data/Packages/Systemd.asset
@@ -0,0 +1,25 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 48447d3db18343398488d3064324147d, type: 3}
+  m_Name: Systemd
+  m_EditorClassIdentifier: 
+  id: pkg_systemd
+  displayName: systemd
+  slot: 2
+  rarity: 5
+  description: first C card each TURN deals 50% more damage. on Arch, btw stacks persist for the whole WAVE.
+  flavourText: one daemon to start them all, stop them all, and explain none of it.
+  designNotes: Arch signature Daemon. Off-distro grants only the first-C-card DamagePipeline multiplier. On Arch also sets persistArchBtw, so the Arch passive skips end-of-TURN btw reset and clears only on WAVE start or rolling-release recovery.
+  intendedDistroId: arch
+  requiresSystem: []
+  offDistroEffect: {kind: 25, amount: 150, threshold: 1, refundCycle: 0, cleanseDebuffs: 0, enableFedoraSecondCardPassive: 0, persistArchBtw: 0}
+  onDistroEffect: {kind: 25, amount: 150, threshold: 1, refundCycle: 0, cleanseDebuffs: 0, enableFedoraSecondCardPassive: 0, persistArchBtw: 1}
diff --git a/Assets/Data/Passives/IUseArchBtw.asset b/Assets/Data/Passives/IUseArchBtw.asset
new file mode 100644
index 0000000..98eac94
--- /dev/null
+++ b/Assets/Data/Passives/IUseArchBtw.asset
@@ -0,0 +1,19 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 9b1f51fb7c354203a2f93ad22fbeb101, type: 3}
+  m_Name: IUseArchBtw
+  m_EditorClassIdentifier: 
+  id: arch_i_use_arch_btw
+  displayName: I use Arch, btw
+  rulesText: Each card played adds 1 btw until end of turn. C and Rust damage gains +1 per btw. Once per wave, lethal uptime sets Arch to 1 instead and clears btw.
+  flavorText: Compiled from source, emotionally and otherwise.
+  designNotes: V1 base passive. Increment btw before resolving each played card. End of TURN resets btw unless Arch has systemd equipped on-distro. First lethal damage each WAVE consumes rolling-release save, sets uptime to 1, clears btw, and logs a recovery beat.
diff --git a/Assets/Scripts/Combat/CardEffects.cs b/Assets/Scripts/Combat/CardEffects.cs
index ab4f495..4c67810 100644
--- a/Assets/Scripts/Combat/CardEffects.cs
+++ b/Assets/Scripts/Combat/CardEffects.cs
@@ -49,10 +49,35 @@ namespace KernelPanic.Combat
                     ? minAmount
                     : RandomRoll.RollRange(minAmount, maxAmount, new RollContext(context.Source));
 
-                context.DamagePipeline.DealDamage(new DamageRequest(context.Source, target, amount, _language, _trueDamage, _canCrit));
+                bool rustOverkillToShield = _language == Language.Rust || context.Card?.Definition?.Language == Language.Rust;
+                int survivable = rustOverkillToShield
+                    ? _trueDamage ? target.CurrentUptime : target.CurrentUptime + target.Shield
+                    : 0;
+                DamageResult result = context.DamagePipeline.DealDamage(new DamageRequest(context.Source, target, amount, _language, _trueDamage, _canCrit));
+                if (rustOverkillToShield)
+                {
+                    GrantRustOverkillShield(context, result, survivable);
+                }
             }
         }
 
+        private static void GrantRustOverkillShield(CombatContext context, DamageResult result, int survivable)
+        {
+            int overkill = UnityEngine.Mathf.Max(0, result.IncomingAmount - survivable);
+            if (overkill <= 0)
+            {
+                return;
+            }
+
+            if (!context.CombatManager.CanPlayerReceiveCardShield(context.Card))
+            {
+                context.CombatManager.ReportEffectResult($"overkill shield blocked: {overkill}");
+                return;
+            }
+
+            context.CombatManager.GrantPlayerShield(overkill, "rust overkill");
+        }
+
         private static IReadOnlyList<CombatantState> ShuffleTargets(IReadOnlyList<CombatantState> targets, CombatantState source)
         {
             List<CombatantState> shuffled = targets.ToList();
@@ -164,6 +189,177 @@ namespace KernelPanic.Combat
         }
     }
 
+    public sealed class SegfaultDamageEffect : ICardEffect
+    {
+        private readonly int _amount;
+        private readonly int _selfDamage;
+        private readonly int _segfaultPercent;
+        private readonly bool _trueDamage;
+        private readonly bool _drawOnSegfault;
+
+        public SegfaultDamageEffect(int amount, int selfDamage, int segfaultPercent, bool trueDamage = false, bool drawOnSegfault = false)
+        {
+            _amount = amount;
+            _selfDamage = selfDamage;
+            _segfaultPercent = segfaultPercent;
+            _trueDamage = trueDamage;
+            _drawOnSegfault = drawOnSegfault;
+        }
+
+        public void Execute(CombatContext context)
+        {
+            new DealDamageEffect(_amount, _amount, Language.C, _trueDamage).Execute(context);
+            bool segfault = RandomRoll.RollRange(1, 100, new RollContext(context.Source)) <= _segfaultPercent;
+            if (!segfault)
+            {
+                return;
+            }
+
+            context.DamagePipeline.DealDamage(new DamageRequest(context.Source, context.Source, _selfDamage, Language.C, false, false));
+            context.CombatManager.ReportEffectResult($"segfault: took {_selfDamage}");
+            if (_drawOnSegfault)
+            {
+                context.CombatManager.DrawCards(2, "free() recoil");
+            }
+        }
+    }
+
+    public sealed class PreviousLanguageDamageEffect : ICardEffect
+    {
+        private readonly int _baseAmount;
+        private readonly int _matchingAmount;
+        private readonly Language _language;
+
+        public PreviousLanguageDamageEffect(int baseAmount, int matchingAmount, Language language)
+        {
+            _baseAmount = baseAmount;
+            _matchingAmount = matchingAmount;
+            _language = language;
+        }
+
+        public void Execute(CombatContext context)
+        {
+            bool matches = context.Source != null
+                && context.Source.HasPreviousPlayedCardLanguage
+                && context.Source.PreviousPlayedCardLanguage == _language;
+            int amount = matches ? _matchingAmount : _baseAmount;
+            new DealDamageEffect(amount, amount, _language).Execute(context);
+        }
+    }
+
+    public sealed class BtwScaledDamageEffect : ICardEffect
+    {
+        private readonly int _baseAmount;
+        private readonly int _perBtw;
+        private readonly Language _language;
+
+        public BtwScaledDamageEffect(int baseAmount, int perBtw, Language language)
+        {
+            _baseAmount = baseAmount;
+            _perBtw = perBtw;
+            _language = language;
+        }
+
+        public void Execute(CombatContext context)
+        {
+            int btw = UnityEngine.Mathf.Max(0, context.Source?.ArchBtwStacks ?? 0);
+            int perBtw = UnityEngine.Mathf.Max(_perBtw, context.Source?.ArchMakepkgBtwMultiplier ?? _perBtw);
+            int amount = _baseAmount + (btw * perBtw);
+            new DealDamageEffect(amount, amount, _language).Execute(context);
+        }
+    }
+
+    public sealed class RandomCommonLanguageCardEffect : ICardEffect
+    {
+        public void Execute(CombatContext context)
+        {
+            Language language = RandomRoll.RollRange(0, 1, new RollContext(context.Source)) == 0 ? Language.C : Language.Rust;
+            if (!context.CombatManager.TryCreateGeneratedCard(language, Rarity.Common, out CardInstance generated))
+            {
+                context.CombatManager.ReportEffectResult("TODO card-generation: no C/Rust common available");
+                return;
+            }
+
+            generated.TemporaryCostDelta -= CombatManager.GetCardCost(generated);
+            if (context.HandController.Add(generated))
+            {
+                context.CombatManager.ReportEffectResult($"AUR helper: generated {GetCardName(generated)} at 0c");
+            }
+            else
+            {
+                context.CombatManager.ReportEffectResult("AUR helper: hand full");
+            }
+        }
+
+        private static string GetCardName(CardInstance card)
+        {
+            return card?.Definition == null || string.IsNullOrWhiteSpace(card.Definition.DisplayName) ? card?.Definition?.Id ?? "--" : card.Definition.DisplayName;
+        }
+    }
+
+    public sealed class MinimalInstallEffect : ICardEffect
+    {
+        public void Execute(CombatContext context)
+        {
+            int exhausted = 0;
+            List<CardInstance> candidates = context.HandController.Cards.Where(card => card != null).Take(2).ToList();
+            for (int i = 0; i < candidates.Count; i++)
+            {
+                CardInstance card = candidates[i];
+                if (!context.HandController.Remove(card))
+                {
+                    continue;
+                }
+
+                context.DeckController.Exhaust(card);
+                context.CombatManager.HandleCardExhausted(card);
+                exhausted++;
+            }
+
+            if (exhausted <= 0)
+            {
+                context.CombatManager.ReportEffectResult("minimal install: no hand cards to exhaust");
+                return;
+            }
+
+            int shield = exhausted * 3;
+            if (context.CombatManager.CanPlayerReceiveCardShield(context.Card))
+            {
+                context.CombatManager.GrantPlayerShield(shield, "minimal install");
+            }
+
+            context.Source.Cycles += exhausted;
+            context.CombatManager.ReportEffectResult($"minimal install: exhausted {exhausted}, +{exhausted} Cycle");
+        }
+    }
+
+    public sealed class SizeofDamageEffect : ICardEffect
+    {
+        public void Execute(CombatContext context)
+        {
+            int cCards = context.HandController.Cards.Count(card => card?.Definition != null && card.Definition.Language == Language.C);
+            int amount = 3 * cCards;
+            new DealDamageEffect(amount, amount, Language.C).Execute(context);
+        }
+    }
+
+    public sealed class ConsultWikiEffect : ICardEffect
+    {
+        public void Execute(CombatContext context)
+        {
+            CardInstance broken = context.HandController.Cards.FirstOrDefault(card => card != null && card.IsBroken);
+            if (broken != null)
+            {
+                broken.IsBroken = false;
+                context.CombatManager.DrawCards(1, "consult the wiki");
+                context.CombatManager.ReportEffectResult("fixed a broken card");
+                return;
+            }
+
+            new DealDamageEffect(6, 6, Language.Rust).Execute(context);
+        }
+    }
+
 
     public sealed class ApplyStatusEffect : ICardEffect
     {
@@ -696,13 +892,16 @@ namespace KernelPanic.Combat
                 "lang_py_for_loop" => One(new DealDamageEffect(2, 2, Language.Python, allEnemies: true)),
                 "lang_js_console_log" => One(new DealDamageEffect(3, 9, Language.JavaScript)),
                 "lang_js_fetch" => One(new DealDamageEffect(5, 13, Language.JavaScript)),
-                "lang_rs_fn_main" => One(new OverkillToShieldDamageEffect(6, Language.Rust)),
+                "lang_rs_fn_main" => One(new DealDamageEffect(6, 6, Language.Rust)),
                 "lang_rs_unwrap" => new ICardEffect[]
                 {
                     new DealDamageEffect(9, 9, Language.Rust),
                     new DrawEffect(1)
                 },
                 "lang_rs_borrow" => One(new ShieldEffect(5)),
+                "lang_c_malloc" => One(new SegfaultDamageEffect(8, 3, 20)),
+                "lang_c_printf" => One(new DealDamageEffect(4, 4, Language.C)),
+                "lang_c_pointer" => One(new PreviousLanguageDamageEffect(6, 10, Language.C)),
                 "lang_java_public_static_main" => One(new DealDamageEffect(7, 7, Language.Java)),
                 "lang_java_system_out_println" => One(new DealDamageEffect(5, 5, Language.Java)),
                 "lang_java_new_object" => One(new DealDamageEffect(3, 3, Language.Java)),
@@ -754,6 +953,14 @@ namespace KernelPanic.Combat
                 "fedora_dnf_update" => One(new DealDamageEffect(9, 9, Language.Java)),
                 "fedora_rawhide" => One(new RawhideEffect()),
                 "fedora_selinux" => One(new IncomingAttackHalveEffect(2)),
+                "arch_pacman_syu" => One(new DealDamageEffect(8, 8, Language.C)),
+                "arch_consult_wiki" => One(new ConsultWikiEffect()),
+                "arch_makepkg" => One(new BtwScaledDamageEffect(4, 2, Language.C)),
+                "arch_aur_helper" => One(new RandomCommonLanguageCardEffect()),
+                "arch_minimal_install" => One(new MinimalInstallEffect()),
+                "shop_c_free" => One(new SegfaultDamageEffect(12, 3, 20, drawOnSegfault: true)),
+                "shop_c_sizeof" => One(new SizeofDamageEffect()),
+                "shop_c_kernel_exploit" => One(new SegfaultDamageEffect(25, 8, 50, true)),
                 _ => Todo("card effect is not authored")
             };
         }
@@ -761,10 +968,11 @@ namespace KernelPanic.Combat
         public static bool RequiresSingleTarget(CardDefinition definition)
         {
             return definition?.Id is "lang_js_console_log" or "lang_js_fetch" or "lang_js_typeof" or "mint_fix_broken"
-                or "lang_rs_fn_main" or "lang_rs_unwrap" or "lang_java_public_static_main"
+                or "lang_rs_fn_main" or "lang_rs_unwrap" or "lang_c_malloc" or "lang_c_printf" or "lang_c_pointer" or "lang_java_public_static_main"
                 or "lang_java_system_out_println" or "lang_java_new_object"
                 or "shop_py_list_append" or "shop_js_math_random" or "shop_js_promise_all" or "ubuntu_snap_install"
-                or "mint_nemo" or "fedora_dnf_autoremove" or "fedora_first_to_package" or "fedora_dnf_update";
+                or "mint_nemo" or "fedora_dnf_autoremove" or "fedora_first_to_package" or "fedora_dnf_update"
+                or "arch_pacman_syu" or "arch_consult_wiki" or "arch_makepkg" or "shop_c_free" or "shop_c_sizeof" or "shop_c_kernel_exploit";
         }
 
         public static bool TargetsAllEnemies(CardDefinition definition)
@@ -820,8 +1028,11 @@ namespace KernelPanic.Combat
                 "lang_js_fetch" => $"deal {UpgradeMath.ScaleAmount(5, card)}-{UpgradeMath.ScaleAmount(13, card)}.{marker}",
                 "lang_js_typeof" => $"75%: deal {UpgradeMath.ScaleAmount(8, card)}. 25%: deal 0.{marker}",
                 "lang_rs_fn_main" => $"deal {UpgradeMath.ScaleAmount(6, card)}. overkill becomes shield.{marker}",
-                "lang_rs_unwrap" => $"deal {UpgradeMath.ScaleAmount(9, card)}. draw {UpgradeMath.ScaleAmount(1, card)}.{marker}",
+                "lang_rs_unwrap" => $"deal {UpgradeMath.ScaleAmount(9, card)}. overkill becomes shield. draw {UpgradeMath.ScaleAmount(1, card)}.{marker}",
                 "lang_rs_borrow" => $"gain {UpgradeMath.ScaleShield(5, card)} shield.{marker}",
+                "lang_c_malloc" => $"deal {UpgradeMath.ScaleAmount(8, card)}. 20%: segfault, take 3.{marker}",
+                "lang_c_printf" => $"deal {UpgradeMath.ScaleAmount(4, card)}.{marker}",
+                "lang_c_pointer" => $"deal {UpgradeMath.ScaleAmount(6, card)}; {UpgradeMath.ScaleAmount(10, card)} if the previous card was C.{marker}",
                 "lang_java_public_static_main" => $"uses 2 RAM. deal {UpgradeMath.ScaleAmount(7, card)}. JIT: Java cards cost 1 less this combat each time you play a Java card; discount decays by 1 after each wave.{marker}",
                 "lang_java_system_out_println" => $"uses 2 RAM. deal {UpgradeMath.ScaleAmount(5, card)}. JIT applies; discount decays by 1 after each wave.{marker}",
                 "lang_java_new_object" => $"uses 2 RAM. deal {UpgradeMath.ScaleAmount(3, card)}. JIT applies; discount decays by 1 after each wave.{marker}",
@@ -846,6 +1057,14 @@ namespace KernelPanic.Combat
                 "fedora_dnf_update" => $"deal {UpgradeMath.ScaleAmount(9, card)}. costs 1 less per Java card played this combat.{marker}",
                 "fedora_rawhide" => $"draw {UpgradeMath.ScaleAmount(2, card)}. next card this turn gains bleeding edge.{marker}",
                 "fedora_selinux" => $"next {UpgradeMath.ScaleAmount(2, card)} enemy attacks deal half damage.{marker}",
+                "arch_pacman_syu" => $"deal {UpgradeMath.ScaleAmount(8, card)}. TODO: 20% break a random hand card.{marker}",
+                "arch_consult_wiki" => $"fix a broken card and draw {UpgradeMath.ScaleAmount(1, card)}; if none, deal {UpgradeMath.ScaleAmount(6, card)}.{marker}",
+                "arch_makepkg" => $"deal {UpgradeMath.ScaleAmount(4, card)} + btw x2; x3 at Arch v3+.{marker}",
+                "arch_aur_helper" => $"add a random C/Rust common card to hand; it costs 0 this turn.{marker}",
+                "arch_minimal_install" => $"exhaust up to 2 hand cards. per card: gain 3 Shield and 1 Cycle.{marker}",
+                "shop_c_free" => $"deal {UpgradeMath.ScaleAmount(12, card)}. segfault recoil draws 2.{marker}",
+                "shop_c_sizeof" => $"deal 3 x C cards in hand.{marker}",
+                "shop_c_kernel_exploit" => $"deal {UpgradeMath.ScaleAmount(25, card)} ignoring Shield. 50%: take 8.{marker}",
                 _ => string.IsNullOrWhiteSpace(card.Definition.Description) ? "effect not authored." : $"{card.Definition.Description}{marker}"
             };
         }
diff --git a/Assets/Scripts/Combat/CombatManager.cs b/Assets/Scripts/Combat/CombatManager.cs
index afe189e..0bae309 100644
--- a/Assets/Scripts/Combat/CombatManager.cs
+++ b/Assets/Scripts/Combat/CombatManager.cs
@@ -42,6 +42,7 @@ namespace KernelPanic.Combat
         private int fedoraCrashChance = 10;
         private int cardsPlayedThisTurn;
         private int cardsPlayedThisWave;
+        private int cCardsPlayedThisTurn;
         private int turnNumberThisWave;
         private bool packageShieldBonusTriggeredThisTurn;
         private bool packageTimeshiftTriggeredThisWave;
@@ -214,6 +215,19 @@ namespace KernelPanic.Combat
             card.MarkPlayedThisTurn(cardsPlayedThisTurn == 0);
             cardsPlayedThisTurn++;
             cardsPlayedThisWave++;
+            if (IsDistro("arch"))
+            {
+                playerState.ArchBtwStacks++;
+            }
+
+            playerState.HasPreviousPlayedCardLanguage = playerState.HasLastPlayedCardLanguage;
+            if (playerState.HasLastPlayedCardLanguage)
+            {
+                playerState.PreviousPlayedCardLanguage = playerState.LastPlayedCardLanguage;
+            }
+
+            playerState.LastPlayedCardLanguage = card.Definition.Language;
+            playerState.HasLastPlayedCardLanguage = true;
             if (card.Definition.Language == Language.Java)
             {
                 javaCardsPlayedThisCombat++;
@@ -254,6 +268,11 @@ namespace KernelPanic.Combat
                 ApplyFedoraGrowth(card, rawhideChargeUsed);
             }
 
+            if (card.Definition.Language == Language.C && cCardsPlayedThisTurn == 0 && HasPackageEffect(PackageEffectKind.FirstCThisTurnDamageMultiplier, out PackageEffectData cPackageEffect))
+            {
+                playerState.CurrentCardDamageMultiplierPercent = Mathf.Max(100, cPackageEffect.Amount);
+            }
+
             switch (track)
             {
                 case ResolutionTrack.InterpreterQueue:
@@ -273,6 +292,12 @@ namespace KernelPanic.Combat
             }
 
             playerState.DamageMultiplierPercent = 100;
+            playerState.CurrentCardDamageMultiplierPercent = 100;
+            if (card.Definition.Language == Language.C)
+            {
+                cCardsPlayedThisTurn++;
+            }
+
             ApplyPackageCardPlayedEffects(card);
 
             pendingTargetCard = null;
@@ -485,6 +510,16 @@ namespace KernelPanic.Combat
             return true;
         }
 
+        public void DrawCards(int count, string label)
+        {
+            if (count <= 0)
+            {
+                return;
+            }
+
+            StartCoroutine(DrawCardsToHandSequenced(count, label));
+        }
+
         private void SetPhase(TurnPhase nextPhase)
         {
             if (IsCombatPaused && nextPhase != TurnPhase.Boot)
@@ -566,6 +601,7 @@ namespace KernelPanic.Combat
             fedoraCardsDiscountedThisTurn = 0;
             cardsPlayedThisTurn = 0;
             cardsPlayedThisWave = 0;
+            cCardsPlayedThisTurn = 0;
             turnNumberThisWave = 0;
             packageShieldBonusTriggeredThisTurn = false;
             packageTimeshiftTriggeredThisWave = false;
@@ -617,6 +653,7 @@ namespace KernelPanic.Combat
             turnNumberThisWave = 0;
             packageShieldBonusTriggeredThisTurn = false;
             packageTimeshiftTriggeredThisWave = false;
+            ResetArchWaveState();
 
             List<CardInstance> startingCards = new();
             for (int i = 0; i < runManager.RunDeck.Count; i++)
@@ -650,6 +687,7 @@ namespace KernelPanic.Combat
             playerState.Cycles = playerState.MaxCycles;
             fedoraCardsDiscountedThisTurn = 0;
             cardsPlayedThisTurn = 0;
+            cCardsPlayedThisTurn = 0;
             turnNumberThisWave++;
             packageShieldBonusTriggeredThisTurn = false;
             javaCardsDiscountThisTurn = 0;
@@ -770,6 +808,7 @@ namespace KernelPanic.Combat
                 return;
             }
 
+            ResetArchBtwAtEndOfTurn();
             RemoveDefeatedEnemies();
             CheckWinOrLoss();
             StateChanged?.Invoke();
@@ -1063,6 +1102,11 @@ namespace KernelPanic.Combat
             {
                 GrantPlayerShield(Mathf.Max(0, effect.Amount), "auditd");
             }
+
+            if (HasPackageEffect(PackageEffectKind.TurnStartGenerateLanguageCard, out effect))
+            {
+                GenerateAurPackageCard(effect);
+            }
         }
 
         private void ApplyPackageCardPlayedEffects(CardInstance card)
@@ -1170,8 +1214,77 @@ namespace KernelPanic.Combat
             }
         }
 
+        private void GenerateAurPackageCard(PackageEffectData effect)
+        {
+            if (handController == null || handController.RemainingRam <= 0)
+            {
+                return;
+            }
+
+            int maxRarity = Mathf.Clamp(effect.Threshold, 0, (int)Rarity.Legendary);
+            List<CardDefinition> pool = new();
+            HashSet<string> seenIds = new(StringComparer.OrdinalIgnoreCase);
+            IReadOnlyList<CardDefinition> source = generatedCardPool.Count > 0 ? generatedCardPool : runConfig?.StartingDeck;
+            if (source == null)
+            {
+                Log("AUR: TODO card-generation pool unavailable");
+                return;
+            }
+
+            for (int i = 0; i < source.Count; i++)
+            {
+                CardDefinition definition = source[i];
+                if (definition == null
+                    || definition.IsToken
+                    || definition.IsRunOnly
+                    || (int)definition.Rarity > maxRarity
+                    || definition.Language != Language.C && definition.Language != Language.Rust)
+                {
+                    continue;
+                }
+
+                if (seenIds.Add(definition.Id))
+                {
+                    pool.Add(definition);
+                }
+            }
+
+            if (pool.Count == 0)
+            {
+                Log("AUR: TODO card-generation pool unavailable");
+                return;
+            }
+
+            int index = RandomRoll.RollRange(0, pool.Count - 1, new RollContext(playerState));
+            CardDefinition selected = pool[index];
+            CardInstance generated = new(selected)
+            {
+                TemporaryCostDelta = -Mathf.Clamp(effect.Amount, 0, selected.CycleCost)
+            };
+
+            if (handController.Add(generated))
+            {
+                string discount = effect.Amount > 0 ? " at -1c" : string.Empty;
+                Log($"AUR: generated {GetCardName(generated)}{discount}");
+                StateChanged?.Invoke();
+            }
+        }
+
         private void HandlePackageDamageDealt(DamageDealtEvent payload)
         {
+            if (payload.Target == playerState && playerState != null && playerState.ArchRollingReleaseRecoveredThisHit)
+            {
+                playerState.ArchRollingReleaseRecoveredThisHit = false;
+                string recovery = "rolling release: recovered at 1 Uptime";
+                if (playerState.ArchRollingReleaseShieldOnSave > 0 || playerState.ArchRollingReleaseCyclesOnSave > 0)
+                {
+                    recovery += $", +{playerState.ArchRollingReleaseShieldOnSave} Shield, +{playerState.ArchRollingReleaseCyclesOnSave} Cycle";
+                }
+
+                Log(recovery);
+                StateChanged?.Invoke();
+            }
+
             if (payload.Target != playerState
                 || payload.UptimeDamage <= 0
                 || packageTimeshiftTriggeredThisWave
@@ -1198,6 +1311,39 @@ namespace KernelPanic.Combat
             StateChanged?.Invoke();
         }
 
+        private void ResetArchBtwAtEndOfTurn()
+        {
+            if (!IsDistro("arch") || playerState == null || playerState.ArchBtwStacks <= 0 || ArchBtwPersistsThisWave())
+            {
+                return;
+            }
+
+            playerState.ArchBtwStacks = 0;
+        }
+
+        private void ResetArchWaveState()
+        {
+            if (playerState == null)
+            {
+                return;
+            }
+
+            playerState.ArchBtwStacks = 0;
+            playerState.ArchRollingReleaseSavesRemaining = IsDistro("arch") ? runConfig.DistroVersion >= 5 ? 2 : 1 : 0;
+            playerState.ArchRollingReleaseAvailableThisWave = playerState.ArchRollingReleaseSavesRemaining > 0;
+            playerState.ArchRollingReleaseRecoveredThisHit = false;
+            playerState.HasLastPlayedCardLanguage = false;
+            playerState.HasPreviousPlayedCardLanguage = false;
+        }
+
+        private bool ArchBtwPersistsThisWave()
+        {
+            return IsDistro("arch")
+                && (runConfig.DistroVersion >= 5
+                || HasOnDistroPackageEffect(PackageEffectKind.FirstCThisTurnDamageMultiplier, out PackageEffectData effect)
+                && effect.PersistArchBtw);
+        }
+
         private bool HasOnDistroPackageEffect(PackageEffectKind kind, out PackageEffectData effect)
         {
             effect = default;
@@ -1288,6 +1434,11 @@ namespace KernelPanic.Combat
             state.AllowFlatDamageBuffs = IsDistro("mint") && runConfig.DistroVersion >= 4;
             state.FlatEffectBonus = IsDistro("mint") && runConfig.DistroVersion >= 2 ? 2 : 0;
             state.DamageMultiplierPercent = 100;
+            state.CurrentCardDamageMultiplierPercent = 100;
+            state.ArchBtwDamagePerStack = IsDistro("arch") && runConfig.DistroVersion >= 2 ? 2 : 1;
+            state.ArchMakepkgBtwMultiplier = IsDistro("arch") && runConfig.DistroVersion >= 3 ? 3 : 2;
+            state.ArchRollingReleaseShieldOnSave = IsDistro("arch") && runConfig.DistroVersion >= 4 ? 15 : 0;
+            state.ArchRollingReleaseCyclesOnSave = IsDistro("arch") && runConfig.DistroVersion >= 4 ? 2 : 0;
         }
 
         private bool IsDistro(string id)
diff --git a/Assets/Scripts/Combat/CombatantState.cs b/Assets/Scripts/Combat/CombatantState.cs
index b91e723..3f4c95d 100644
--- a/Assets/Scripts/Combat/CombatantState.cs
+++ b/Assets/Scripts/Combat/CombatantState.cs
@@ -32,7 +32,20 @@ namespace KernelPanic.Combat
         public int FlatEffectBonus { get; set; }
         public int JavaScriptFlatDamageBonus { get; set; }
         public int DamageMultiplierPercent { get; set; } = 100;
+        public int CurrentCardDamageMultiplierPercent { get; set; } = 100;
         public int IncomingAttackHalfCharges { get; set; }
+        public int ArchBtwStacks { get; set; }
+        public int ArchBtwDamagePerStack { get; set; } = 1;
+        public int ArchMakepkgBtwMultiplier { get; set; } = 2;
+        public int ArchRollingReleaseSavesRemaining { get; set; }
+        public int ArchRollingReleaseShieldOnSave { get; set; }
+        public int ArchRollingReleaseCyclesOnSave { get; set; }
+        public bool ArchRollingReleaseAvailableThisWave { get; set; }
+        public bool ArchRollingReleaseRecoveredThisHit { get; set; }
+        public bool HasLastPlayedCardLanguage { get; set; }
+        public Language LastPlayedCardLanguage { get; set; }
+        public bool HasPreviousPlayedCardLanguage { get; set; }
+        public Language PreviousPlayedCardLanguage { get; set; }
         public IReadOnlyList<StatusInstance> Statuses => _statuses;
         public IReadOnlyDictionary<StatusType, int> ActiveStatuses => BuildStatusSnapshot();
 
diff --git a/Assets/Scripts/Combat/DamagePipeline.cs b/Assets/Scripts/Combat/DamagePipeline.cs
index abe242c..b44f21b 100644
--- a/Assets/Scripts/Combat/DamagePipeline.cs
+++ b/Assets/Scripts/Combat/DamagePipeline.cs
@@ -70,6 +70,7 @@ namespace KernelPanic.Combat
             amount = ApplyResistancesAndWeaknesses(amount, request);
 
             int finalAmount = ApplyShieldAndUptime(amount, request, out int absorbedAmount, out int shieldDamage, out int uptimeDamage);
+            ApplyArchRollingReleaseSave(request);
             GameEvents.RaiseDamageDealt(new DamageDealtEvent(request.Source, request.Target, finalAmount, request.Language, amount, absorbedAmount, wasCritical, shieldDamage, uptimeDamage));
 
             bool defeated = false;
@@ -93,7 +94,8 @@ namespace KernelPanic.Combat
             }
 
             int multiplier = request.Source == null ? 100 : Mathf.Max(0, request.Source.DamageMultiplierPercent);
-            return Mathf.RoundToInt(amount * (multiplier / 100f));
+            int currentCardMultiplier = request.Source == null ? 100 : Mathf.Max(0, request.Source.CurrentCardDamageMultiplierPercent);
+            return Mathf.RoundToInt(amount * (multiplier / 100f) * (currentCardMultiplier / 100f));
         }
 
         private static int ApplyFlatAdditions(int amount, DamageRequest request)
@@ -103,6 +105,11 @@ namespace KernelPanic.Combat
                 amount += Mathf.Max(0, request.Source.JavaScriptFlatDamageBonus);
             }
 
+            if (request.Source != null && (request.Language == Language.C || request.Language == Language.Rust))
+            {
+                amount += Mathf.Max(0, request.Source.ArchBtwStacks) * Mathf.Max(1, request.Source.ArchBtwDamagePerStack);
+            }
+
             return amount;
         }
 
@@ -114,10 +121,29 @@ namespace KernelPanic.Combat
                 return amount;
             }
 
-            wasCritical = RandomRoll.RollRange(1, 100, new RollContext(request.Source)) <= 25;
+            int critChance = request.Language == Language.C ? 50 : 25;
+            wasCritical = RandomRoll.RollRange(1, 100, new RollContext(request.Source)) <= critChance;
             return wasCritical ? Mathf.CeilToInt(amount * 1.5f) : amount;
         }
 
+        private static void ApplyArchRollingReleaseSave(DamageRequest request)
+        {
+            CombatantState target = request.Target;
+            if (target == null || target.CurrentUptime > 0 || target.ArchRollingReleaseSavesRemaining <= 0)
+            {
+                return;
+            }
+
+            target.ArchRollingReleaseSavesRemaining--;
+            target.ArchRollingReleaseAvailableThisWave = target.ArchRollingReleaseSavesRemaining > 0;
+            target.ArchBtwStacks = 0;
+            target.CurrentUptime = 1;
+            target.Shield += Mathf.Max(0, target.ArchRollingReleaseShieldOnSave);
+            target.Cycles += Mathf.Max(0, target.ArchRollingReleaseCyclesOnSave);
+            target.IsDefeated = false;
+            target.ArchRollingReleaseRecoveredThisHit = true;
+        }
+
         private static int ApplyResistancesAndWeaknesses(int amount, DamageRequest request)
         {
             // TODO: Enemy resistances/reductions are not authored yet. Mint V5 should re-resolve
diff --git a/Assets/Scripts/Data/PackageDefinition.cs b/Assets/Scripts/Data/PackageDefinition.cs
index 26d7edd..5b150fe 100644
--- a/Assets/Scripts/Data/PackageDefinition.cs
+++ b/Assets/Scripts/Data/PackageDefinition.cs
@@ -37,7 +37,9 @@ namespace KernelPanic.Data
         FirstInterpreterQueueCardEachWaveShield = 21,
         EveryNthTurnDraw = 22,
         StartTurnNoDebuffShield = 23,
-        EveryNthCardEachWaveCycle = 24
+        EveryNthCardEachWaveCycle = 24,
+        FirstCThisTurnDamageMultiplier = 25,
+        TurnStartGenerateLanguageCard = 26
     }
 
     [Serializable]
@@ -49,8 +51,9 @@ namespace KernelPanic.Data
         [SerializeField] private bool refundCycle;
         [SerializeField] private bool cleanseDebuffs;
         [SerializeField] private bool enableFedoraSecondCardPassive;
+        [SerializeField] private bool persistArchBtw;
 
-        public PackageEffectData(PackageEffectKind kind, int amount, int threshold, bool refundCycle, bool cleanseDebuffs, bool enableFedoraSecondCardPassive)
+        public PackageEffectData(PackageEffectKind kind, int amount, int threshold, bool refundCycle, bool cleanseDebuffs, bool enableFedoraSecondCardPassive, bool persistArchBtw = false)
         {
             this.kind = kind;
             this.amount = amount;
@@ -58,6 +61,7 @@ namespace KernelPanic.Data
             this.refundCycle = refundCycle;
             this.cleanseDebuffs = cleanseDebuffs;
             this.enableFedoraSecondCardPassive = enableFedoraSecondCardPassive;
+            this.persistArchBtw = persistArchBtw;
         }
 
         public PackageEffectKind Kind => kind;
@@ -66,6 +70,7 @@ namespace KernelPanic.Data
         public bool RefundCycle => refundCycle;
         public bool CleanseDebuffs => cleanseDebuffs;
         public bool EnableFedoraSecondCardPassive => enableFedoraSecondCardPassive;
+        public bool PersistArchBtw => persistArchBtw;
     }
 
     /// <summary>
@@ -142,7 +147,7 @@ namespace KernelPanic.Data
             }
 
             int amount = effect.Amount + GetAmountPerLevel(effect.Kind, effect.Amount) * level;
-            return new PackageEffectData(effect.Kind, amount, effect.Threshold, effect.RefundCycle, effect.CleanseDebuffs, effect.EnableFedoraSecondCardPassive);
+            return new PackageEffectData(effect.Kind, amount, effect.Threshold, effect.RefundCycle, effect.CleanseDebuffs, effect.EnableFedoraSecondCardPassive, effect.PersistArchBtw);
         }
 
         private static int GetAmountPerLevel(PackageEffectKind kind, int baseAmount)
@@ -159,6 +164,7 @@ namespace KernelPanic.Data
                 PackageEffectKind.FirstCardEachWaveCostReduction => 1,
                 PackageEffectKind.FirstNativeCardEachWaveFlatDamage => 1,
                 PackageEffectKind.JavaScriptFlatDamage => 1,
+                PackageEffectKind.TurnStartGenerateLanguageCard => 0,
                 _ => 1
             };
         }
diff --git a/Assets/Scripts/Meta/DistroVersionCatalog.cs b/Assets/Scripts/Meta/DistroVersionCatalog.cs
index cfec5c9..b767d7e 100644
--- a/Assets/Scripts/Meta/DistroVersionCatalog.cs
+++ b/Assets/Scripts/Meta/DistroVersionCatalog.cs
@@ -9,7 +9,8 @@ namespace KernelPanic.Meta
         {
             ["ubuntu"] = new[] { "20.04", "21.04", "22.04", "23.04", "24.04" },
             ["fedora"] = new[] { "38", "39", "40", "41", "42" },
-            ["mint"] = new[] { "21", "21.2", "21.3", "22", "22.1" }
+            ["mint"] = new[] { "21", "21.2", "21.3", "22", "22.1" },
+            ["arch"] = new[] { "2024.01", "2024.06", "2024.12", "2025.06", "2025.12" }
         };
 
         public static string GetReleaseLabel(string unitId, int version)
@@ -55,6 +56,15 @@ namespace KernelPanic.Meta
                     5 => "timeshift snapshot restores to full uptime if lower",
                     _ => "--"
                 },
+                "arch" => safeVersion switch
+                {
+                    1 => "btw stacks add C/Rust damage; once per wave, lethal uptime recovers to 1",
+                    2 => "btw stacks add +2 C/Rust damage instead of +1",
+                    3 => "makepkg scales at btw x3 instead of x2",
+                    4 => "rolling-release recovery also grants 15 Shield and 2 Cycles",
+                    5 => "btw persists for the wave and rolling release can save twice per wave",
+                    _ => "--"
+                },
                 _ => safeVersion == 1 ? "base release" : $"V{safeVersion} release effect"
             };
         }
diff --git a/Assets/Scripts/Meta/GachaService.cs b/Assets/Scripts/Meta/GachaService.cs
index 54805fa..39369ea 100644
--- a/Assets/Scripts/Meta/GachaService.cs
+++ b/Assets/Scripts/Meta/GachaService.cs
@@ -309,6 +309,21 @@ namespace KernelPanic.Meta
             };
         }
 
+        public static bool IsBeginnerInstallMediaDistro(DistroDefinition distro)
+        {
+            return distro != null
+                && (string.Equals(distro.Id, "ubuntu", StringComparison.OrdinalIgnoreCase)
+                    || string.Equals(distro.Id, "fedora", StringComparison.OrdinalIgnoreCase)
+                    || string.Equals(distro.Id, "mint", StringComparison.OrdinalIgnoreCase)
+                    || string.Equals(distro.Id, "arch", StringComparison.OrdinalIgnoreCase));
+        }
+
+        public static bool IsBeginnerStarterDistro(DistroDefinition distro)
+        {
+            return IsBeginnerInstallMediaDistro(distro)
+                && !string.Equals(distro.Id, "arch", StringComparison.OrdinalIgnoreCase);
+        }
+
         public static double GetFiveStarChance(GachaBannerState state)
         {
             return GetFiveStarChance(state == null ? 0 : state.fiveStarPityCounter);
@@ -353,7 +368,8 @@ namespace KernelPanic.Meta
             if (pullNumber == 50)
             {
                 _beginnerState.pityCounter = 0;
-                return GachaReward.FutureStandardFiveStar("future standard 5-star distro", "50-pull beginner capstone");
+                _beginnerState.fiveStarPityCounter = 0;
+                return RewardGuaranteedBeginnerFiveStar("50-pull beginner guarantee");
             }
 
             if (TryRollFiveStar(_beginnerState, out bool fiveStarPityTriggered))
@@ -372,8 +388,11 @@ namespace KernelPanic.Meta
             _beginnerState.pityCounter = 0;
             if (_bannerPool.Count > 0 && _random.NextDouble() < DistroChanceOnFeaturedTier)
             {
-                DistroDefinition distro = _bannerPool[_random.Next(_bannerPool.Count)];
-                return GachaReward.DistroReward(distro, 4, pityTriggered, false);
+                DistroDefinition distro = FindRandomBannerPoolDistroByStars(4);
+                if (distro != null)
+                {
+                    return GachaReward.DistroReward(distro, 4, pityTriggered, false);
+                }
             }
 
             return GachaReward.Package(4, "4-star package", pityTriggered, false);
@@ -413,8 +432,18 @@ namespace KernelPanic.Meta
                 return GachaReward.Package(5, "5-star package", pityTriggered, false);
             }
 
-            DistroDefinition distro = _bannerPool.Count == 0 ? null : _bannerPool[_random.Next(_bannerPool.Count)];
-            return GachaReward.DistroReward(distro, 5, pityTriggered, false);
+            DistroDefinition distro = FindRandomBannerPoolDistroByStars(5);
+            return distro == null
+                ? GachaReward.Package(5, "5-star package", pityTriggered, false)
+                : GachaReward.DistroReward(distro, 5, pityTriggered, false);
+        }
+
+        private GachaReward RewardGuaranteedBeginnerFiveStar(string reason)
+        {
+            DistroDefinition distro = FindRandomBannerPoolDistroByStars(5);
+            return distro == null
+                ? GachaReward.Package(5, "5-star package", true, true)
+                : GachaReward.DistroReward(distro, 5, true, true, reason);
         }
 
         public bool ResolveFeaturedTierIsDistro()
@@ -446,16 +475,16 @@ namespace KernelPanic.Meta
             DistroDefinition distro = null;
             if (guaranteeIndex >= 0 && guaranteeIndex < _beginnerState.guaranteedDistroIds.Count)
             {
-                distro = FindBannerPoolDistro(_beginnerState.guaranteedDistroIds[guaranteeIndex]);
+                distro = FindBannerPoolDistroByStars(_beginnerState.guaranteedDistroIds[guaranteeIndex], 4);
             }
 
-            distro ??= _bannerPool.Count == 0 ? null : _bannerPool[Math.Min(guaranteeIndex, _bannerPool.Count - 1)];
+            distro ??= FindBannerPoolDistroByStars(guaranteeIndex, 4);
             return distro == null
                 ? GachaReward.Package(4, "4-star package", true, true)
                 : GachaReward.DistroReward(distro, 4, true, true, reason);
         }
 
-        private DistroDefinition FindBannerPoolDistro(string id)
+        private DistroDefinition FindBannerPoolDistroByStars(string id, int stars)
         {
             if (string.IsNullOrWhiteSpace(id))
             {
@@ -465,7 +494,7 @@ namespace KernelPanic.Meta
             for (int i = 0; i < _bannerPool.Count; i++)
             {
                 DistroDefinition distro = _bannerPool[i];
-                if (distro != null && string.Equals(distro.Id, id, StringComparison.OrdinalIgnoreCase))
+                if (distro != null && GetDistroStars(distro) == stars && string.Equals(distro.Id, id, StringComparison.OrdinalIgnoreCase))
                 {
                     return distro;
                 }
@@ -474,6 +503,48 @@ namespace KernelPanic.Meta
             return null;
         }
 
+        private DistroDefinition FindBannerPoolDistroByStars(int index, int stars)
+        {
+            int seen = 0;
+            for (int i = 0; i < _bannerPool.Count; i++)
+            {
+                DistroDefinition distro = _bannerPool[i];
+                if (distro == null || GetDistroStars(distro) != stars)
+                {
+                    continue;
+                }
+
+                if (seen == index)
+                {
+                    return distro;
+                }
+
+                seen++;
+            }
+
+            return null;
+        }
+
+        private DistroDefinition FindRandomBannerPoolDistroByStars(int stars)
+        {
+            List<DistroDefinition> eligible = new();
+            for (int i = 0; i < _bannerPool.Count; i++)
+            {
+                DistroDefinition distro = _bannerPool[i];
+                if (distro != null && GetDistroStars(distro) == stars)
+                {
+                    eligible.Add(distro);
+                }
+            }
+
+            return eligible.Count == 0 ? null : eligible[_random.Next(eligible.Count)];
+        }
+
+        private static int GetDistroStars(DistroDefinition distro)
+        {
+            return distro != null && string.Equals(distro.Id, "arch", StringComparison.OrdinalIgnoreCase) ? 5 : 4;
+        }
+
         private void SetCurrencyBalanceSilently(GachaCurrencyType currencyType, int amount)
         {
             _currencyBalances[currencyType] = Math.Max(0, amount);
diff --git a/Assets/Scripts/Run/RunManager.cs b/Assets/Scripts/Run/RunManager.cs
index 9932820..aa3649a 100644
--- a/Assets/Scripts/Run/RunManager.cs
+++ b/Assets/Scripts/Run/RunManager.cs
@@ -391,7 +391,7 @@ namespace KernelPanic.Run
                         continue;
                     }
 
-                    if (card.IsRunOnly || card.Language == CurrentConfig.PrimaryLanguage || card.Language == CurrentConfig.SecondaryLanguage)
+                    if (card.Language == CurrentConfig.PrimaryLanguage || card.Language == CurrentConfig.SecondaryLanguage)
                     {
                         pool.Add(card);
                     }
diff --git a/Assets/Scripts/UI/CollectionScreenController.cs b/Assets/Scripts/UI/CollectionScreenController.cs
index 229ec51..712ba30 100644
--- a/Assets/Scripts/UI/CollectionScreenController.cs
+++ b/Assets/Scripts/UI/CollectionScreenController.cs
@@ -707,7 +707,7 @@ namespace KernelPanic.UI
 
         private static int GetDistroStars(DistroDefinition unit)
         {
-            return 4;
+            return unit != null && string.Equals(unit.Id, "arch", StringComparison.OrdinalIgnoreCase) ? 5 : 4;
         }
 
         private static Color GetLanguageColor(Language language)
@@ -2024,6 +2024,8 @@ namespace KernelPanic.UI
                 PackageEffectKind.JavaScriptFlatDamage => $"+{amount} JavaScript damage",
                 PackageEffectKind.WaveThresholdRestore => $"restore {amount} Uptime after wave {effect.Threshold}",
                 PackageEffectKind.DnfFedoraPassive => "Fedora passive can trigger twice",
+                PackageEffectKind.FirstCThisTurnDamageMultiplier => $"first C card each turn deals {amount}% damage",
+                PackageEffectKind.TurnStartGenerateLanguageCard => amount > 0 ? "turn start: generate C/Rust card at -1c" : "turn start: generate common C/Rust card",
                 _ => amount > 0 ? $"+{amount} package effect" : "package effect"
             };
         }
diff --git a/Assets/Scripts/UI/GachaScreenController.cs b/Assets/Scripts/UI/GachaScreenController.cs
index 231d7e0..a7c7ff6 100644
--- a/Assets/Scripts/UI/GachaScreenController.cs
+++ b/Assets/Scripts/UI/GachaScreenController.cs
@@ -607,7 +607,7 @@ namespace KernelPanic.UI
             IReadOnlyList<string> ids = _gachaService.BeginnerState.guaranteedDistroIds;
             string first = ids.Count > 0 ? ids[0] : "--";
             string second = ids.Count > 1 ? ids[1] : "--";
-            return $"20={first}, 40={second}, 50=future standard 5-star";
+            return $"20={first}, 40={second}, 50=guaranteed 5-star";
         }
 
         private static VisualElement BuildInfoLine(string key, string value)
diff --git a/Assets/Scripts/UI/GamblingSceneController.cs b/Assets/Scripts/UI/GamblingSceneController.cs
index 004e135..cb4cd0d 100644
--- a/Assets/Scripts/UI/GamblingSceneController.cs
+++ b/Assets/Scripts/UI/GamblingSceneController.cs
@@ -517,12 +517,16 @@ namespace KernelPanic.UI
                 }
             }
 
-            if (saveData.starterChosen && gacha.BannerPool.Count == 0)
+            if (saveData.starterChosen)
             {
                 IReadOnlyList<DistroDefinition> distros = distroDatabase.AllDistros;
                 for (int i = 0; i < distros.Count; i++)
                 {
-                    gacha.AddToBannerPool(distros[i]);
+                    DistroDefinition distro = distros[i];
+                    if (GachaService.IsBeginnerInstallMediaDistro(distro))
+                    {
+                        gacha.AddToBannerPool(distro);
+                    }
                 }
             }
         }
diff --git a/Assets/Scripts/UI/MainMenuController.cs b/Assets/Scripts/UI/MainMenuController.cs
index 15964fa..910729c 100644
--- a/Assets/Scripts/UI/MainMenuController.cs
+++ b/Assets/Scripts/UI/MainMenuController.cs
@@ -707,7 +707,7 @@ namespace KernelPanic.UI
 
             if (_saveData.starterChosen)
             {
-                AddAllFourStarDistrosToBeginnerBannerPool();
+                AddBeginnerInstallMediaDistrosToBannerPool();
             }
 
             if (_gachaService.BeginnerState.guaranteedDistroIds.Count == 0 && _saveData.bannerPoolIds.Count > 0)
@@ -730,7 +730,7 @@ namespace KernelPanic.UI
             }
         }
 
-        private void AddAllFourStarDistrosToBeginnerBannerPool()
+        private void AddBeginnerInstallMediaDistrosToBannerPool()
         {
             if (distroDatabase == null)
             {
@@ -740,7 +740,11 @@ namespace KernelPanic.UI
             IReadOnlyList<DistroDefinition> distros = distroDatabase.AllDistros;
             for (int i = 0; i < distros.Count; i++)
             {
-                _gachaService.AddToBannerPool(distros[i]);
+                DistroDefinition distro = distros[i];
+                if (GachaService.IsBeginnerInstallMediaDistro(distro))
+                {
+                    _gachaService.AddToBannerPool(distro);
+                }
             }
         }
 
@@ -806,7 +810,7 @@ namespace KernelPanic.UI
         private void HandleStarterConfirmed(DistroDefinition picked, IReadOnlyList<DistroDefinition> remaining)
         {
             _playerCollection.Add(picked, 1);
-            AddAllFourStarDistrosToBeginnerBannerPool();
+            AddBeginnerInstallMediaDistrosToBannerPool();
             _gachaService.SetBeginnerGuaranteedDistros(remaining);
             _saveData.starterChosen = true;
             SaveCurrentState();
diff --git a/Assets/Scripts/UI/StarterSelectionController.cs b/Assets/Scripts/UI/StarterSelectionController.cs
index 70de3fe..157292e 100644
--- a/Assets/Scripts/UI/StarterSelectionController.cs
+++ b/Assets/Scripts/UI/StarterSelectionController.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using KernelPanic.Data;
+using KernelPanic.Meta;
 using UnityEngine;
 using UnityEngine.UIElements;
 
@@ -196,7 +197,24 @@ namespace KernelPanic.UI
                 return false;
             }
 
-            starters = allDistros;
+            List<DistroDefinition> starterDistros = new();
+            for (int i = 0; i < allDistros.Count; i++)
+            {
+                DistroDefinition distro = allDistros[i];
+                if (GachaService.IsBeginnerStarterDistro(distro))
+                {
+                    starterDistros.Add(distro);
+                }
+            }
+
+            if (starterDistros.Count < StarterCount)
+            {
+                starters = Array.Empty<DistroDefinition>();
+                error = $"DistroDatabase needs at least {StarterCount} starter distros (found {starterDistros.Count})";
+                return false;
+            }
+
+            starters = starterDistros;
             error = null;
             return true;
         }