diff --git a/components/HAMiBlastRadiusAnimation.jsx b/components/HAMiBlastRadiusAnimation.jsx
new file mode 100644
index 000000000..160ae7661
--- /dev/null
+++ b/components/HAMiBlastRadiusAnimation.jsx
@@ -0,0 +1,289 @@
+export default function HAMiBlastRadiusAnimation() {
+  return (
+    <figure className="hami-blast" aria-labelledby="hami-blast-title">
+      <style dangerouslySetInnerHTML={{ __html: `
+        .hami-blast {
+          margin: 2rem 0;
+          overflow: hidden;
+          border: 1px solid var(--border-subtle);
+          border-radius: 8px;
+          background: var(--bg-card);
+          box-shadow: var(--card-shadow);
+        }
+
+        .hami-blast * { box-sizing: border-box; }
+
+        .hami-blast__inner {
+          padding: clamp(1rem, 3vw, 1.6rem);
+        }
+
+        .hami-blast__eyebrow {
+          margin: 0 0 0.35rem;
+          color: #e03131;
+          font-size: 0.72rem;
+          font-weight: 900;
+          text-transform: uppercase;
+        }
+
+        .hami-blast__title {
+          margin: 0;
+          color: var(--text-primary);
+          font-size: clamp(1.15rem, 2.5vw, 1.55rem);
+          line-height: 1.25;
+        }
+
+        .hami-blast__subtitle {
+          max-width: 49rem;
+          margin: 0.55rem 0 1.25rem;
+          color: var(--text-secondary);
+          font-size: 0.92rem;
+          line-height: 1.6;
+        }
+
+        .hami-blast__gpu {
+          position: relative;
+          padding: clamp(0.9rem, 2vw, 1.25rem);
+          border: 3px solid #495057;
+          border-radius: 6px 9px 5px 8px;
+          background: color-mix(in srgb, #868e96 8%, var(--bg-elevated));
+        }
+
+        .hami-blast__gpu::after {
+          content: '';
+          position: absolute;
+          inset: 5px -5px -5px 5px;
+          z-index: -1;
+          border: 1px solid color-mix(in srgb, #495057 45%, transparent);
+          border-radius: inherit;
+        }
+
+        .hami-blast__gpu-head {
+          display: flex;
+          flex-wrap: wrap;
+          justify-content: space-between;
+          gap: 0.5rem;
+          margin-bottom: 0.9rem;
+          color: var(--text-primary);
+          font-size: 0.78rem;
+          font-weight: 900;
+        }
+
+        .hami-blast__pods {
+          display: grid;
+          grid-template-columns: repeat(2, minmax(0, 1fr));
+          gap: 0.9rem;
+        }
+
+        .hami-blast__pod {
+          position: relative;
+          min-width: 0;
+          min-height: 14rem;
+          padding: 0.9rem;
+          border: 2px solid var(--pod-color);
+          border-radius: 5px 8px 4px 7px;
+          background: color-mix(in srgb, var(--pod-color) 10%, var(--bg-card));
+        }
+
+        .hami-blast__pod h4,
+        .hami-blast__pod p { margin: 0; }
+
+        .hami-blast__pod h4 {
+          color: var(--text-primary);
+          font-size: 0.92rem;
+        }
+
+        .hami-blast__pod p {
+          margin-top: 0.3rem;
+          color: var(--text-secondary);
+          font-size: 0.72rem;
+          line-height: 1.4;
+        }
+
+        .hami-blast__meter {
+          position: absolute;
+          right: 0.9rem;
+          bottom: 0.9rem;
+          left: 0.9rem;
+          height: 6.4rem;
+          overflow: hidden;
+          border: 1px solid var(--border-medium);
+          border-radius: 5px;
+          background: var(--bg-elevated);
+        }
+
+        .hami-blast__fill {
+          position: absolute;
+          right: 0;
+          bottom: 0;
+          left: 0;
+          height: var(--steady-height);
+          background: color-mix(in srgb, var(--pod-color) 58%, var(--bg-card));
+        }
+
+        .hami-blast__pod--spike .hami-blast__fill {
+          animation: hamiBlastFill 7s ease-in-out infinite;
+        }
+
+        .hami-blast__limit {
+          position: absolute;
+          top: 0;
+          right: 0;
+          left: 0;
+          border-top: 2px dashed #e03131;
+        }
+
+        .hami-blast__meter-label {
+          position: absolute;
+          right: 0.4rem;
+          bottom: 0.35rem;
+          left: 0.4rem;
+          color: var(--text-primary);
+          font-size: 0.67rem;
+          font-weight: 900;
+          text-align: center;
+        }
+
+        .hami-blast__attempt {
+          position: absolute;
+          top: 0.55rem;
+          right: 0.55rem;
+          left: 0.55rem;
+          padding: 0.36rem;
+          border: 2px solid #e03131;
+          border-radius: 4px 6px 3px 5px;
+          background: color-mix(in srgb, #ffc9c9 58%, var(--bg-card));
+          color: #a51111;
+          font-size: 0.66rem;
+          font-weight: 950;
+          line-height: 1.25;
+          text-align: center;
+          opacity: 0;
+          animation: hamiBlastReject 7s ease-in-out infinite;
+        }
+
+        .dark .hami-blast__attempt { color: #ffb3b3; }
+
+        .hami-blast__steady {
+          position: absolute;
+          top: 0.55rem;
+          right: 0.55rem;
+          left: 0.55rem;
+          padding: 0.36rem;
+          border: 1px solid #2f9e44;
+          border-radius: 4px 6px 3px 5px;
+          background: color-mix(in srgb, #b2f2bb 34%, var(--bg-card));
+          color: #18712d;
+          font-size: 0.66rem;
+          font-weight: 950;
+          text-align: center;
+          animation: hamiBlastSteady 7s ease-in-out infinite;
+        }
+
+        .dark .hami-blast__steady { color: #8ce99a; }
+
+        .hami-blast__result {
+          display: grid;
+          grid-template-columns: repeat(3, minmax(0, 1fr));
+          gap: 0.65rem;
+          margin-top: 1rem;
+        }
+
+        .hami-blast__result div {
+          min-width: 0;
+          padding: 0.72rem;
+          border: 1px solid var(--border-subtle);
+          border-radius: 6px;
+          background: var(--bg-card);
+          color: var(--text-secondary);
+          font-size: 0.72rem;
+          line-height: 1.4;
+          text-align: center;
+        }
+
+        .hami-blast__result strong {
+          display: block;
+          margin-bottom: 0.2rem;
+          color: var(--text-primary);
+          font-size: 0.76rem;
+        }
+
+        @keyframes hamiBlastFill {
+          0%, 15%, 100% { height: 26%; }
+          35% { height: 45%; }
+          52% { height: 66%; }
+          68%, 83% { height: 90%; }
+        }
+
+        @keyframes hamiBlastReject {
+          0%, 60%, 100% { opacity: 0; transform: scale(0.94); }
+          68%, 86% { opacity: 1; transform: scale(1); }
+        }
+
+        @keyframes hamiBlastSteady {
+          0%, 100% { opacity: 0.72; }
+          65%, 88% { opacity: 1; box-shadow: 0 0 0 4px color-mix(in srgb, #51cf66 20%, transparent); }
+        }
+
+        @media (max-width: 620px) {
+          .hami-blast__pods,
+          .hami-blast__result { grid-template-columns: 1fr; }
+          .hami-blast__pod { min-height: 13rem; }
+        }
+
+        @media (prefers-reduced-motion: reduce) {
+          .hami-blast__fill,
+          .hami-blast__attempt,
+          .hami-blast__steady { animation: none !important; }
+          .hami-blast__pod--spike .hami-blast__fill { height: 90%; }
+          .hami-blast__attempt { opacity: 1; }
+        }
+      ` }} />
+
+      <div className="hami-blast__inner">
+        <p className="hami-blast__eyebrow">Measured OOM sequence</p>
+        <h3 className="hami-blast__title" id="hami-blast-title">
+          One container crosses 8,000 MiB; its neighbor keeps running
+        </h3>
+        <p className="hami-blast__subtitle">
+          Both containers share the same physical RTX PRO 6000. Their HAMi memory accounts are separate.
+        </p>
+
+        <div className="hami-blast__gpu" aria-hidden="true">
+          <div className="hami-blast__gpu-head">
+            <span>Physical GPU 5</span>
+            <span>97,887 MiB real VRAM</span>
+          </div>
+
+          <div className="hami-blast__pods">
+            <div className="hami-blast__pod hami-blast__pod--spike" style={{ '--pod-color': '#e03131' }}>
+              <h4>Container A</h4>
+              <p>8,000 MiB grant · allocation spike</p>
+              <div className="hami-blast__meter">
+                <span className="hami-blast__fill" style={{ '--pod-color': '#e03131', '--steady-height': '26%' }} />
+                <span className="hami-blast__limit" />
+                <span className="hami-blast__attempt">next 1.49 GiB allocation → OOM</span>
+                <span className="hami-blast__meter-label">peaked at 7,235 MiB before rejection</span>
+              </div>
+            </div>
+
+            <div className="hami-blast__pod" style={{ '--pod-color': '#2f9e44' }}>
+              <h4>Container B</h4>
+              <p>8,000 MiB grant · steady matmul loop</p>
+              <div className="hami-blast__meter">
+                <span className="hami-blast__fill" style={{ '--pod-color': '#2f9e44', '--steady-height': '26%' }} />
+                <span className="hami-blast__steady">Running · 0 restarts</span>
+                <span className="hami-blast__meter-label">held 2,107 MiB throughout</span>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <div className="hami-blast__result">
+          <div><strong>Quota that tripped</strong>8,388,608,000 bytes</div>
+          <div><strong>Attempted total</strong>9,185,657,856 bytes</div>
+          <div><strong>Physical card</strong>still had ample headroom</div>
+        </div>
+      </div>
+    </figure>
+  );
+}
diff --git a/components/HAMiRequestFlowAnimation.jsx b/components/HAMiRequestFlowAnimation.jsx
new file mode 100644
index 000000000..61b6d3b67
--- /dev/null
+++ b/components/HAMiRequestFlowAnimation.jsx
@@ -0,0 +1,240 @@
+const STEPS = [
+  { label: 'Pod request', detail: '1 GPU · 8000 MiB · 10%', color: '#1971c2' },
+  { label: 'Webhook', detail: 'routes the pod to HAMi', color: '#9c36b5' },
+  { label: 'Scheduler', detail: 'checks slot + memory + core', color: '#e8590c' },
+  { label: 'Device plugin', detail: 'mounts devices + libvgpu', color: '#0b7285' },
+  { label: 'HAMi-Core', detail: 'enforces inside the container', color: '#5d8f00' },
+  { label: 'Physical GPU', detail: 'runs the accepted CUDA work', color: '#495057' },
+];
+
+export default function HAMiRequestFlowAnimation() {
+  return (
+    <figure className="hami-request-flow" aria-labelledby="hami-request-flow-title">
+      <style dangerouslySetInnerHTML={{ __html: `
+        .hami-request-flow {
+          margin: 2rem 0;
+          overflow: hidden;
+          border: 1px solid var(--border-subtle);
+          border-radius: 8px;
+          background: var(--bg-card);
+          box-shadow: var(--card-shadow);
+        }
+
+        .hami-request-flow * { box-sizing: border-box; }
+
+        .hami-request-flow__inner {
+          padding: clamp(1rem, 3vw, 1.6rem);
+        }
+
+        .hami-request-flow__eyebrow {
+          margin: 0 0 0.35rem;
+          color: #1971c2;
+          font-size: 0.72rem;
+          font-weight: 900;
+          text-transform: uppercase;
+        }
+
+        .dark .hami-request-flow__eyebrow { color: #74c0fc; }
+
+        .hami-request-flow__title {
+          margin: 0;
+          color: var(--text-primary);
+          font-size: clamp(1.15rem, 2.5vw, 1.55rem);
+          line-height: 1.25;
+        }
+
+        .hami-request-flow__subtitle {
+          max-width: 49rem;
+          margin: 0.55rem 0 1.25rem;
+          color: var(--text-secondary);
+          font-size: 0.92rem;
+          line-height: 1.6;
+        }
+
+        .hami-request-flow__stage {
+          position: relative;
+          display: grid;
+          grid-template-columns: repeat(6, minmax(0, 1fr));
+          gap: 0.7rem;
+          padding: 1.15rem 0.8rem;
+          border: 2px dashed color-mix(in srgb, var(--text-secondary) 38%, transparent);
+          border-radius: 7px 5px 8px 6px;
+          background: color-mix(in srgb, var(--bg-elevated) 84%, transparent);
+        }
+
+        .hami-request-flow__rail {
+          position: absolute;
+          top: 50%;
+          right: 5%;
+          left: 5%;
+          height: 3px;
+          border-top: 3px dashed color-mix(in srgb, #5d8f00 55%, var(--border-medium));
+          transform: translateY(-50%);
+        }
+
+        .hami-request-flow__packet {
+          position: absolute;
+          top: calc(50% - 0.38rem);
+          left: 5%;
+          width: 0.76rem;
+          height: 0.76rem;
+          border: 2px solid #4c6ef5;
+          border-radius: 3px 5px 2px 4px;
+          background: #a5d8ff;
+          box-shadow: 0 0 0 4px color-mix(in srgb, #74c0fc 24%, transparent);
+          animation: hamiRequestPacket 7.2s ease-in-out infinite;
+        }
+
+        .hami-request-flow__step {
+          position: relative;
+          z-index: 1;
+          min-width: 0;
+          min-height: 8.6rem;
+          padding: 0.8rem 0.55rem;
+          border: 2px solid var(--step-color);
+          border-radius: 5px 8px 4px 7px;
+          background: color-mix(in srgb, var(--step-color) 12%, var(--bg-card));
+          transform: rotate(var(--tilt));
+          animation: hamiRequestStep 7.2s ease-in-out infinite;
+          animation-delay: calc(var(--step) * 0.72s);
+        }
+
+        .hami-request-flow__step::after {
+          content: '';
+          position: absolute;
+          inset: 3px -3px -3px 3px;
+          z-index: -1;
+          border: 1px solid color-mix(in srgb, var(--step-color) 42%, transparent);
+          border-radius: inherit;
+        }
+
+        .hami-request-flow__number {
+          display: grid;
+          place-items: center;
+          width: 1.65rem;
+          height: 1.65rem;
+          margin: 0 auto 0.65rem;
+          border: 1px solid var(--step-color);
+          border-radius: 50%;
+          background: var(--bg-card);
+          color: var(--step-color);
+          font-size: 0.74rem;
+          font-weight: 950;
+        }
+
+        .hami-request-flow__step strong,
+        .hami-request-flow__step span {
+          display: block;
+          overflow-wrap: anywhere;
+          text-align: center;
+        }
+
+        .hami-request-flow__step strong {
+          color: var(--text-primary);
+          font-size: 0.78rem;
+          line-height: 1.25;
+        }
+
+        .hami-request-flow__step span {
+          margin-top: 0.45rem;
+          color: var(--text-secondary);
+          font-size: 0.67rem;
+          line-height: 1.35;
+        }
+
+        .hami-request-flow__footer {
+          display: grid;
+          grid-template-columns: repeat(2, minmax(0, 1fr));
+          gap: 0.8rem;
+          margin-top: 1rem;
+        }
+
+        .hami-request-flow__note {
+          min-width: 0;
+          padding: 0.8rem;
+          border-left: 4px solid var(--note-color);
+          background: color-mix(in srgb, var(--note-color) 8%, var(--bg-card));
+          color: var(--text-secondary);
+          font-size: 0.8rem;
+          line-height: 1.45;
+        }
+
+        .hami-request-flow__note strong {
+          display: block;
+          margin-bottom: 0.18rem;
+          color: var(--text-primary);
+        }
+
+        @keyframes hamiRequestPacket {
+          0%, 8% { left: 5%; opacity: 0; transform: scale(0.75); }
+          13% { opacity: 1; transform: scale(1); }
+          87% { left: calc(95% - 0.76rem); opacity: 1; transform: scale(1); }
+          94%, 100% { left: calc(95% - 0.76rem); opacity: 0; transform: scale(0.75); }
+        }
+
+        @keyframes hamiRequestStep {
+          0%, 12%, 100% { box-shadow: none; }
+          19%, 28% { box-shadow: 0 0 0 5px color-mix(in srgb, var(--step-color) 18%, transparent); }
+        }
+
+        @media (max-width: 850px) {
+          .hami-request-flow__stage { grid-template-columns: repeat(3, minmax(0, 1fr)); }
+          .hami-request-flow__rail,
+          .hami-request-flow__packet { display: none; }
+          .hami-request-flow__step { min-height: 7.6rem; }
+        }
+
+        @media (max-width: 520px) {
+          .hami-request-flow__stage { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+          .hami-request-flow__footer { grid-template-columns: 1fr; }
+        }
+
+        @media (prefers-reduced-motion: reduce) {
+          .hami-request-flow__packet,
+          .hami-request-flow__step { animation: none !important; }
+        }
+      ` }} />
+
+      <div className="hami-request-flow__inner">
+        <p className="hami-request-flow__eyebrow">Animated request path</p>
+        <h3 className="hami-request-flow__title" id="hami-request-flow-title">
+          Scheduling decides where; HAMi-Core controls what happens inside
+        </h3>
+        <p className="hami-request-flow__subtitle">
+          A memory request is checked before placement, then enforced again when the application actually allocates VRAM.
+        </p>
+
+        <div className="hami-request-flow__stage" aria-hidden="true">
+          <span className="hami-request-flow__rail" />
+          <span className="hami-request-flow__packet" />
+          {STEPS.map((step, index) => (
+            <div
+              className="hami-request-flow__step"
+              style={{
+                '--step': index,
+                '--step-color': step.color,
+                '--tilt': `${index % 2 === 0 ? -0.45 : 0.45}deg`,
+              }}
+              key={step.label}
+            >
+              <span className="hami-request-flow__number">{index + 1}</span>
+              <strong>{step.label}</strong>
+              <span>{step.detail}</span>
+            </div>
+          ))}
+        </div>
+
+        <div className="hami-request-flow__footer">
+          <div className="hami-request-flow__note" style={{ '--note-color': '#e8590c' }}>
+            <strong>Before the container starts</strong>
+            The scheduler rejects a request that cannot fit the card&apos;s remaining slot, memory, or core budget.
+          </div>
+          <div className="hami-request-flow__note" style={{ '--note-color': '#5d8f00' }}>
+            <strong>While the process runs</strong>
+            <code>libvgpu.so</code> intercepts supported CUDA/NVML paths and returns OOM when this container crosses its grant.
+          </div>
+        </div>
+      </div>
+    </figure>
+  );
+}
diff --git a/components/HAMiSlotMathAnimation.jsx b/components/HAMiSlotMathAnimation.jsx
new file mode 100644
index 000000000..dbaf75f55
--- /dev/null
+++ b/components/HAMiSlotMathAnimation.jsx
@@ -0,0 +1,279 @@
+const GPU_COUNT = 8;
+const SLOTS_PER_GPU = 10;
+
+export default function HAMiSlotMathAnimation() {
+  return (
+    <figure className="hami-slot-math" aria-labelledby="hami-slot-math-title">
+      <style dangerouslySetInnerHTML={{ __html: `
+        .hami-slot-math {
+          margin: 2rem 0;
+          overflow: hidden;
+          border: 1px solid var(--border-subtle);
+          border-radius: 8px;
+          background: var(--bg-card);
+          box-shadow: var(--card-shadow);
+        }
+
+        .hami-slot-math * { box-sizing: border-box; }
+
+        .hami-slot-math__inner {
+          padding: clamp(1rem, 3vw, 1.6rem);
+        }
+
+        .hami-slot-math__eyebrow {
+          margin: 0 0 0.35rem;
+          color: #5d8f00;
+          font-size: 0.72rem;
+          font-weight: 900;
+          text-transform: uppercase;
+        }
+
+        .dark .hami-slot-math__eyebrow { color: #a3e635; }
+
+        .hami-slot-math__title {
+          margin: 0;
+          color: var(--text-primary);
+          font-size: clamp(1.15rem, 2.5vw, 1.55rem);
+          line-height: 1.25;
+        }
+
+        .hami-slot-math__subtitle {
+          max-width: 48rem;
+          margin: 0.55rem 0 1.25rem;
+          color: var(--text-secondary);
+          font-size: 0.92rem;
+          line-height: 1.6;
+        }
+
+        .hami-slot-math__stage {
+          display: grid;
+          grid-template-columns: minmax(0, 0.85fr) auto minmax(0, 1.15fr);
+          gap: clamp(0.8rem, 2vw, 1.4rem);
+          align-items: center;
+          padding: clamp(0.8rem, 2vw, 1.2rem);
+          border: 2px dashed color-mix(in srgb, var(--text-secondary) 38%, transparent);
+          border-radius: 7px 5px 8px 6px;
+          background: color-mix(in srgb, var(--bg-elevated) 84%, transparent);
+        }
+
+        .hami-slot-math__label {
+          margin: 0 0 0.7rem;
+          color: var(--text-primary);
+          font-size: 0.8rem;
+          font-weight: 900;
+          text-align: center;
+        }
+
+        .hami-slot-math__gpus {
+          display: grid;
+          grid-template-columns: repeat(4, minmax(0, 1fr));
+          gap: 0.45rem;
+        }
+
+        .hami-slot-math__gpu {
+          position: relative;
+          display: grid;
+          place-items: center;
+          aspect-ratio: 1.35;
+          min-width: 0;
+          border: 2px solid #1971c2;
+          border-radius: 5px 8px 4px 7px;
+          background: color-mix(in srgb, #74c0fc 22%, var(--bg-card));
+          color: var(--text-primary);
+          font-size: 0.72rem;
+          font-weight: 900;
+          transform: rotate(var(--tilt));
+        }
+
+        .hami-slot-math__gpu::after {
+          content: '';
+          position: absolute;
+          inset: 3px -3px -3px 3px;
+          z-index: -1;
+          border: 1px solid color-mix(in srgb, #1971c2 48%, transparent);
+          border-radius: inherit;
+        }
+
+        .hami-slot-math__multiply {
+          display: grid;
+          place-items: center;
+          gap: 0.2rem;
+          color: #e8590c;
+          text-align: center;
+        }
+
+        .hami-slot-math__multiply strong {
+          font-size: clamp(1.5rem, 4vw, 2.5rem);
+          line-height: 1;
+        }
+
+        .hami-slot-math__multiply span {
+          max-width: 7rem;
+          color: var(--text-secondary);
+          font-size: 0.68rem;
+          font-weight: 800;
+          line-height: 1.3;
+        }
+
+        .hami-slot-math__slots {
+          display: grid;
+          grid-template-columns: repeat(10, minmax(0, 1fr));
+          gap: 0.22rem;
+        }
+
+        .hami-slot-math__slot {
+          aspect-ratio: 1;
+          min-width: 0;
+          border: 1px solid #5d8f00;
+          border-radius: 3px 5px 2px 4px;
+          background: color-mix(in srgb, #76b900 15%, var(--bg-card));
+          animation: hamiSlotPulse 5.4s ease-in-out infinite;
+          animation-delay: calc(var(--slot) * 0.035s);
+        }
+
+        .hami-slot-math__budgets {
+          display: grid;
+          grid-template-columns: repeat(2, minmax(0, 1fr));
+          gap: 0.8rem;
+          margin-top: 1rem;
+        }
+
+        .hami-slot-math__budget {
+          min-width: 0;
+          padding: 0.8rem;
+          border: 1px solid var(--border-subtle);
+          border-radius: 6px;
+          background: var(--bg-card);
+        }
+
+        .hami-slot-math__budget-head {
+          display: flex;
+          justify-content: space-between;
+          gap: 0.6rem;
+          color: var(--text-primary);
+          font-size: 0.76rem;
+          font-weight: 900;
+        }
+
+        .hami-slot-math__bar {
+          height: 0.55rem;
+          margin-top: 0.55rem;
+          overflow: hidden;
+          border: 1px solid var(--border-medium);
+          border-radius: 999px;
+          background: var(--bg-elevated);
+        }
+
+        .hami-slot-math__bar::before {
+          content: '';
+          display: block;
+          width: 100%;
+          height: 100%;
+          background: var(--bar-color);
+          transform-origin: left;
+          animation: hamiBudgetHold 5.4s ease-in-out infinite;
+        }
+
+        .hami-slot-math__takeaway {
+          margin: 1rem 0 0;
+          color: var(--text-secondary);
+          font-size: 0.84rem;
+          line-height: 1.5;
+          text-align: center;
+        }
+
+        .hami-slot-math__takeaway strong { color: var(--text-primary); }
+        .hami-slot-math__takeaway code {
+          color: inherit;
+          font-size: 0.82em;
+        }
+
+        @keyframes hamiSlotPulse {
+          0%, 15%, 100% { background: color-mix(in srgb, #76b900 15%, var(--bg-card)); transform: scale(1); }
+          30%, 62% { background: color-mix(in srgb, #76b900 48%, var(--bg-card)); transform: scale(0.88); }
+        }
+
+        @keyframes hamiBudgetHold {
+          0%, 100% { transform: scaleX(1); opacity: 0.75; }
+          45%, 65% { transform: scaleX(1); opacity: 1; }
+        }
+
+        @media (max-width: 720px) {
+          .hami-slot-math__stage { grid-template-columns: 1fr; }
+          .hami-slot-math__multiply { grid-template-columns: auto auto; }
+          .hami-slot-math__slots { grid-template-columns: repeat(10, minmax(0, 1fr)); }
+          .hami-slot-math__budgets { grid-template-columns: 1fr; }
+        }
+
+        @media (prefers-reduced-motion: reduce) {
+          .hami-slot-math__slot,
+          .hami-slot-math__bar::before {
+            animation: none !important;
+          }
+        }
+      ` }} />
+
+      <div className="hami-slot-math__inner">
+        <p className="hami-slot-math__eyebrow">Scheduling math</p>
+        <h3 className="hami-slot-math__title" id="hami-slot-math-title">
+          Eight physical GPUs can expose 80 slots without becoming 80 GPUs
+        </h3>
+        <p className="hami-slot-math__subtitle">
+          HAMi multiplies how many containers may share a card. It does not multiply the card&apos;s memory or compute.
+        </p>
+
+        <div className="hami-slot-math__stage" aria-hidden="true">
+          <div>
+            <p className="hami-slot-math__label">Hardware on the node</p>
+            <div className="hami-slot-math__gpus">
+              {Array.from({ length: GPU_COUNT }, (_, index) => (
+                <span
+                  className="hami-slot-math__gpu"
+                  style={{ '--tilt': `${index % 2 === 0 ? -0.8 : 0.8}deg` }}
+                  key={index}
+                >
+                  GPU {index}
+                </span>
+              ))}
+            </div>
+          </div>
+
+          <div className="hami-slot-math__multiply">
+            <strong>×10</strong>
+            <span>maximum sharing slots per card</span>
+          </div>
+
+          <div>
+            <p className="hami-slot-math__label">Logical slots Kubernetes counts</p>
+            <div className="hami-slot-math__slots">
+              {Array.from({ length: GPU_COUNT * SLOTS_PER_GPU }, (_, index) => (
+                <span className="hami-slot-math__slot" style={{ '--slot': index }} key={index} />
+              ))}
+            </div>
+          </div>
+        </div>
+
+        <div className="hami-slot-math__budgets">
+          <div className="hami-slot-math__budget">
+            <div className="hami-slot-math__budget-head">
+              <span>Physical VRAM</span>
+              <span>8 × 97,887 MiB</span>
+            </div>
+            <div className="hami-slot-math__bar" style={{ '--bar-color': '#1971c2' }} />
+          </div>
+          <div className="hami-slot-math__budget">
+            <div className="hami-slot-math__budget-head">
+              <span>Physical compute</span>
+              <span>8 × 100%</span>
+            </div>
+            <div className="hami-slot-math__bar" style={{ '--bar-color': '#e8590c' }} />
+          </div>
+        </div>
+
+        <p className="hami-slot-math__takeaway">
+          <strong><code>deviceSplitCount</code> is a concurrency ceiling.</strong> Memory and core requests still have to fit the real card.
+        </p>
+      </div>
+    </figure>
+  );
+}
diff --git a/content/blog/sharing-gpus-in-kubernetes-with-hami.md b/content/blog/sharing-gpus-in-kubernetes-with-hami.md
new file mode 100644
index 000000000..fced87f48
--- /dev/null
+++ b/content/blog/sharing-gpus-in-kubernetes-with-hami.md
@@ -0,0 +1,902 @@
+---
+title: "How to Share GPUs in Kubernetes at Scale with HAMi (Software vGPU Slicing)"
+seoTitle: "HAMi vGPU on Kubernetes: Software GPU Slicing From 8 GPUs to 80 Schedulable Slices"
+seoDescription: "Share NVIDIA GPUs in Kubernetes with HAMi software vGPU slicing: memory and compute limits, Helm configuration, a verified PyTorch manifest, a real RTX PRO 6000 OOM test, and Prometheus monitoring."
+datePublished: 2026-07-23T10:00:00.000Z
+slug: sharing-gpus-in-kubernetes-with-hami
+author: shubham-katara
+authors: ["shubham-katara", "saiyam-pathak"]
+cover: /img/blog/sharing-gpus-in-kubernetes-with-hami/cover.png
+tags: ["kubernetes", "gpu", "nvidia", "platform-engineering"]
+sponsor:
+  name: Utho
+  url: "https://utho.com/?utm_source=Kubesimplify&utm_medium=docs&utm_campaign=Saiyam"
+  # logoLight = navy mark (shown on light theme); logoDark = white mark (shown on dark theme)
+  logoLight: /img/sponsors/utho-logo-light.png
+  logoDark: /img/sponsors/utho-logo-dark.png
+  blurb: "This deep dive ran on an 8x NVIDIA RTX PRO 6000 Blackwell node from Utho Cloud. If you need GPU infrastructure to run workloads like these, take a look."
+---
+
+Your platform team did everything right. You bought MIG-capable GPUs, carved them into hardware-isolated slices exactly like we did in [the MIG deep dive](/blog/slicing-gpus-in-kubernetes-with-nvidia-mig), and stopped handing a whole 96GB card to every notebook that asked for one. And yet the tickets keep coming.
+
+One team needs 8GB of VRAM, but the smallest MIG profile on our RTX PRO 6000 is `1g.24gb`. That leaves most of the slice unused. Another workload needs 30GB, which does not match the available 24GB or 48GB profiles cleanly. Changing a MIG geometry also means stopping workloads that occupy the instances you need to destroy and recreate.
+
+On Ampere GPUs, toggling MIG mode itself can additionally require a GPU reset; Hopper and newer GPUs no longer require that reset. NVIDIA documents the exact [RTX PRO 6000 profiles](https://docs.nvidia.com/datacenter/tesla/mig-user-guide/supported-mig-profiles.html#rtx-pro-6000-blackwell-mig-profiles) and the [generation-specific reset behavior](https://docs.nvidia.com/datacenter/tesla/mig-user-guide/getting-started-with-mig.html#enable-mig-mode).
+
+Then there is the rest of the fleet: NVIDIA cards that do not support MIG, or clusters where fixed hardware partitions are simply the wrong fit. Kubernetes normally treats a GPU as an indivisible extended resource, so a pod asking for one GPU can occupy a whole card even when it uses only a small part of the memory and compute.
+
+**HAMi (Heterogeneous AI Computing Virtualization Middleware)** adds a software sharing layer. In plain English, it gives Kubernetes three numbers to work with:
+
+- **How many physical GPUs does this container need?** `nvidia.com/gpu`
+- **How much memory may it use on each GPU?** `nvidia.com/gpumem`, in MiB
+- **How much compute time may it receive?** `nvidia.com/gpucores`, in 1% steps
+
+HAMi is now a [CNCF Incubating project](https://www.cncf.io/projects/hami/), and its maintained [device support matrix](https://project-hami.io/docs/userguide/device-supported) covers NVIDIA plus several other accelerator families through vendor-specific plugins.
+
+This walkthrough runs on our actual test rig: **8 NVIDIA RTX PRO 6000 Blackwell Server Edition GPUs**. All eight cards are in non-MIG mode, and `deviceSplitCount: 10` makes Kubelet report `8 × 10 = 80` logical scheduling slots. That does **not** create 80 GPUs or multiply the machine's VRAM. It creates 80 scheduling slots backed by the same eight cards. The exact live command and output appear below.
+
+For this guide, we rebuilt that node as a clean single-node Kubernetes v1.35.6 cluster, installed HAMi v2.9.0 as a new Helm release, and then ran the sharing and quota tests you will see below. The point is not merely to show the final YAML. It is to make every software layer between the physical GPU and the pod understandable.
+
+Who this is for:
+
+- Platform engineers who already run (or have evaluated) NVIDIA MIG and want to know what changes when isolation moves from silicon to software.
+- Teams who need finer-grained GPU fractions than MIG's fixed profiles allow, or whose cards don't support MIG at all.
+
+What you'll get from this guide:
+
+- Why a GPU node may advertise more scheduling units than physical cards, what that number means, and what actually limits placement.
+- A mental model for how HAMi enforces memory and compute limits without touching the hardware's memory crossbars.
+- The exact Helm values that control the split factor, and how to size a workload's `nvidia.com/gpumem` / `nvidia.com/gpucores` requests.
+- A verified Deployment manifest running a PyTorch workload against a HAMi vGPU slice on a Blackwell (`sm_120`) card.
+- A concrete blast-radius test with captured output: one pod's process allocates past its memory grant while a second pod shares the same physical card.
+
+The lab has one Kubernetes node, so this post does not pretend to benchmark multi-node scheduling. The same device-plugin architecture extends to every labeled GPU node, but cluster-scale policy and failure testing are separate exercises.
+
+## The Problem: Fixed Hardware Profiles vs. Flexible Software Budgets
+
+MIG solves the "one pod locks a whole 96GB card" problem by carving the GPU into hardware-isolated partitions. On this RTX PRO 6000, those partitions come in fixed profiles such as `1g.24gb`, `2g.48gb`, and `4g.96gb`.
+
+That creates its own friction:
+
+- If a workload needs 8GB, the smallest standard compute profile on this card is still 24GB. You waste less than with a whole card, but you still waste 16GB.
+- A workload that needs 30GB does not fit the 24GB profile, so it must take 48GB.
+- Changing the profile layout requires destroying and recreating affected MIG instances. That is operationally heavier than changing a pod resource request.
+- MIG only works on supported GPUs and software combinations. It is not a universal sharing mechanism for every NVIDIA card.
+
+**HAMi** takes a different approach. Instead of partitioning the silicon, its NVIDIA path combines device-aware scheduling with HAMi-Core, an injected user-space library. The `hami-scheduler` reserves a memory and compute budget; HAMi-Core tracks supported CUDA allocations and throttles compute while the container runs. The official [GPU virtualization walkthrough](https://project-hami.io/docs/core-concepts/gpu-virtualization) documents the complete webhook → scheduler → device plugin → HAMi-Core flow.
+
+That means:
+
+- Memory can be requested in 1 MiB units: `nvidia.com/gpumem: 8000` is valid, rather than choosing a fixed profile name.
+- No GPU reset is required to change how a card is divided. The limits live in the pod spec, not the hardware.
+- Compute can be requested in 1% steps with `nvidia.com/gpucores`.
+- HAMi provides a common scheduling model across multiple accelerator families, with capabilities and plugins that vary by vendor. This article tests only the NVIDIA HAMi-Core path.
+
+The tradeoff is the boundary. HAMi's NVIDIA limits are enforced in user space by intercepting CUDA/NVML paths. MIG's memory and compute boundaries are implemented in hardware. Both can prevent an ordinary CUDA workload from consuming another tenant's allocation, but they are not equivalent isolation guarantees.
+
+{{hami-request-flow-animation}}
+
+## Before Installing HAMi: The Four Layers
+
+GPU setup becomes confusing when four different jobs are described as if they were one installation. Keep this stack in your head:
+
+1. **NVIDIA driver:** lets Linux communicate with the physical GPU. `nvidia-smi` proves this layer works.
+2. **NVIDIA Container Toolkit:** lets a container runtime expose that GPU inside a container.
+3. **Kubernetes:** places pods on nodes and asks a device plugin for the devices assigned to each container.
+4. **HAMi:** replaces whole-GPU scheduling with device-aware placement plus software memory and compute limits.
+
+HAMi does not replace the driver, Container Toolkit, containerd, or Kubernetes. It builds on them.
+
+Our clean test node used:
+
+- **Host OS:** Ubuntu 24.04.4 LTS on Utho Cloud.
+- **Kubernetes:** v1.35.6, one control-plane node (`utho-gpu-rtxpro6000-8-62383`).
+- **Container runtime:** containerd 2.2.1.
+- **GPUs:** 8x NVIDIA RTX PRO 6000 Blackwell Server Edition.
+- **Memory per GPU:** 97,887 MiB reported by the driver.
+- **NVIDIA driver:** 610.43.02.
+- **NVIDIA Container Toolkit:** 1.19.1.
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# nvidia-smi -L
+GPU 0: NVIDIA RTX PRO 6000 Blackwell Server Edition (UUID: GPU-8b89b58e-b427-108d-ac50-06138d78fe78)
+GPU 1: NVIDIA RTX PRO 6000 Blackwell Server Edition (UUID: GPU-03a041b7-8abf-360a-d1a2-dfd70188cd5f)
+GPU 2: NVIDIA RTX PRO 6000 Blackwell Server Edition (UUID: GPU-ba09367f-dd50-32ca-e988-7ff66bece885)
+GPU 3: NVIDIA RTX PRO 6000 Blackwell Server Edition (UUID: GPU-30512c46-708b-f374-5698-ee24be6cd626)
+GPU 4: NVIDIA RTX PRO 6000 Blackwell Server Edition (UUID: GPU-4c395b7a-a7e6-d90f-1ced-d96e8dd68288)
+GPU 5: NVIDIA RTX PRO 6000 Blackwell Server Edition (UUID: GPU-04dc48d7-7048-aef5-ad36-f5db716e7668)
+GPU 6: NVIDIA RTX PRO 6000 Blackwell Server Edition (UUID: GPU-f4f5db98-143f-0a8d-47ce-956fab39a736)
+GPU 7: NVIDIA RTX PRO 6000 Blackwell Server Edition (UUID: GPU-f4c61521-240a-da09-2787-e576034e197e)
+```
+
+## Build the Kubernetes 1.35 Cluster
+
+If you already have a healthy Kubernetes cluster, do not reset it just to follow this guide. We rebuilt a dedicated test node so the installation path was clean. The package commands below follow Kubernetes' official [kubeadm installation guide](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/).
+
+First enable the kernel settings Kubernetes networking needs and turn off swap:
+
+```bash
+sudo swapoff -a
+sudo modprobe overlay
+sudo modprobe br_netfilter
+
+cat <<'EOF' | sudo tee /etc/sysctl.d/99-kubernetes-cri.conf
+net.bridge.bridge-nf-call-iptables  = 1
+net.bridge.bridge-nf-call-ip6tables = 1
+net.ipv4.ip_forward                 = 1
+EOF
+
+sudo sysctl --system
+```
+
+`swapoff -a` changes the running system only. If this node may reboot, also disable its swap entry in `/etc/fstab` or the corresponding systemd swap unit before treating the cluster as persistent.
+
+Add the Kubernetes v1.35 package repository and install the node tools:
+
+```bash
+sudo apt-get update
+sudo apt-get install -y apt-transport-https ca-certificates curl gpg
+sudo mkdir -p -m 755 /etc/apt/keyrings
+
+curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.35/deb/Release.key \
+  | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
+
+echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.35/deb/ /' \
+  | sudo tee /etc/apt/sources.list.d/kubernetes.list
+
+sudo apt-get update
+sudo apt-get install -y kubelet kubeadm kubectl
+sudo apt-mark hold kubelet kubeadm kubectl
+```
+
+### Make the NVIDIA runtime the default
+
+The host already had its NVIDIA driver and Container Toolkit. We configured containerd with the NVIDIA runtime and made it the default, which is also the setup expected by HAMi's [prerequisites](https://project-hami.io/docs/installation/prerequisites):
+
+```bash
+sudo nvidia-ctk runtime configure \
+  --runtime=containerd \
+  --set-as-default
+sudo systemctl restart containerd
+```
+
+Verify the result instead of assuming it worked:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# containerd config dump \
+  | grep -E 'default_runtime_name|BinaryName' | head -2
+      default_runtime_name = 'nvidia'
+            BinaryName = '/usr/bin/nvidia-container-runtime'
+```
+
+### Initialize the control plane
+
+The `10.244.0.0/16` pod network below matches Flannel's default manifest:
+
+```bash
+PUBLIC_IP="<PUBLIC_IP>"
+
+sudo kubeadm init \
+  --kubernetes-version v1.35.6 \
+  --apiserver-advertise-address "$PUBLIC_IP" \
+  --pod-network-cidr 10.244.0.0/16 \
+  --cri-socket unix:///run/containerd/containerd.sock
+
+mkdir -p "$HOME/.kube"
+sudo cp /etc/kubernetes/admin.conf "$HOME/.kube/config"
+sudo chown "$(id -u):$(id -g)" "$HOME/.kube/config"
+```
+
+This is a one-node lab, so the control-plane node must also accept workloads. Do not remove this taint on a production control plane unless that is an intentional design decision:
+
+```bash
+kubectl taint nodes --all node-role.kubernetes.io/control-plane-
+kubectl apply -f \
+  https://github.com/flannel-io/flannel/releases/download/v0.28.7/kube-flannel.yml
+```
+
+The rebuilt node came up on the expected versions:
+
+```text
+NAME                          STATUS   KUBERNETES   RUNTIME
+utho-gpu-rtxpro6000-8-62383   Ready    v1.35.6      containerd://2.2.1
+```
+
+## RuntimeClass and GPU Operator: Which Path Are We Using?
+
+It is reasonable to expect an `nvidia` RuntimeClass if you normally install GPUs through the **NVIDIA GPU Operator**. Many Operator configurations create it.
+
+That is not a universal rule anymore. In current GPU Operator releases, ordinary CDI (Container Device Interface)-injected workloads do not need to name a RuntimeClass, and enabling the newer NRI plugin deliberately removes the `nvidia` RuntimeClass. NVIDIA documents those mode differences in its [CDI and NRI guide](https://docs.nvidia.com/datacenter/cloud-native/gpu-operator/latest/cdi.html).
+
+This lab does **not** install GPU Operator. The host already has the driver and Container Toolkit, and containerd's default runtime is `nvidia`. Therefore:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl get runtimeclass
+No resources found
+```
+
+That empty output is correct for this setup. The later workload works without `runtimeClassName` because the NVIDIA runtime is already the default.
+
+If your cluster already uses GPU Operator, do not run two device plugins that both advertise `nvidia.com/gpu`. HAMi's [GPU Operator compatibility guidance](https://project-hami.io/docs/faq) says to disable the Operator-managed device plugin (`devicePlugin.enabled=false`) when HAMi owns NVIDIA GPU scheduling. Keep the Operator for the driver/toolkit lifecycle if you need it; let HAMi own the conflicting device-plugin role.
+
+## Install HAMi From Scratch
+
+HAMi's NVIDIA device plugin selects nodes labeled `gpu=on` by default, so label the GPU node first:
+
+```bash
+kubectl label node utho-gpu-rtxpro6000-8-62383 gpu=on --overwrite
+```
+
+Now install a pinned HAMi chart. We pin its bundled `kube-scheduler` sidecar to the same version as the API server. Kubernetes' [version-skew policy](https://kubernetes.io/releases/version-skew-policy/#kube-controller-manager-kube-scheduler-and-cloud-controller-manager) expects the same minor version and permits the scheduler to be one minor older; an exact match simply removes avoidable skew from this lab. Notice the full Helm path, `scheduler.kubeScheduler.image.tag`; `scheduler.kubeScheduler.imageTag` is not a chart 2.9.0 value and would be silently ignored. The remaining values make the sharing policy explicit instead of hiding important behavior behind defaults:
+
+```bash
+helm repo add hami-charts https://project-hami.github.io/HAMi/
+helm repo update hami-charts
+
+K8S_VERSION=$(kubectl version -o json | jq -r '.serverVersion.gitVersion')
+
+helm install hami hami-charts/hami \
+  --version 2.9.0 \
+  --namespace hami-system \
+  --create-namespace \
+  --wait \
+  --timeout 10m \
+  --set scheduler.kubeScheduler.image.tag="$K8S_VERSION" \
+  --set devicePlugin.deviceSplitCount=10 \
+  --set devicePlugin.deviceMemoryScaling=1 \
+  --set devicePlugin.deviceCoreScaling=1 \
+  --set devicePlugin.migStrategy=none \
+  --set devicePlugin.createRuntimeClass=false \
+  --set-string devicePlugin.disablecorelimit=false
+```
+
+This is the release created by that command, not a dry-run render or an inherited installation:
+
+```text
+NAME   NAMESPACE    REVISION   STATUS     CHART        APP VERSION
+hami   hami-system  1          deployed   hami-2.9.0   2.9.0
+```
+
+Both HAMi components became healthy:
+
+```text
+NAME                              READY   STATUS    RESTARTS
+hami-device-plugin-5wdzg          2/2     Running   0
+hami-scheduler-6f74879cc7-9fddb   2/2     Running   0
+```
+
+The scheduler pod is cluster-wide. The device-plugin DaemonSet runs once on every selected GPU node. During the final review, we read the capacity and allocatable values directly from the live Node object:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl get node utho-gpu-rtxpro6000-8-62383 \
+  -o custom-columns='NAME:.metadata.name,KUBERNETES:.status.nodeInfo.kubeletVersion,GPU-CAPACITY:.status.capacity.nvidia\.com/gpu,GPU-ALLOCATABLE:.status.allocatable.nvidia\.com/gpu'
+NAME                          KUBERNETES   GPU-CAPACITY   GPU-ALLOCATABLE
+utho-gpu-rtxpro6000-8-62383   v1.35.6      80             80
+```
+
+That `80` is the real output from the all-eight non-MIG configuration: eight registered physical cards, each contributing ten logical device IDs.
+
+### Where did `nvidia.com/gpu` come from?
+
+Not from RuntimeClass, and not directly from GPU Operator. A **device plugin** is the component that registers an extended resource with Kubelet.
+
+In a typical GPU Operator installation, the Operator deploys NVIDIA's official device plugin, which registers `nvidia.com/gpu`. In this installation, there is no GPU Operator or NVIDIA device-plugin DaemonSet. The HAMi chart installed **`hami-device-plugin`**, and that plugin owns the same resource name:
+
+```text
+NAME                 READY   DESIRED   IMAGE
+hami-device-plugin   1       1         docker.io/projecthami/hami:v2.9.0
+```
+
+The live sequence is:
+
+1. The host NVIDIA driver exposes eight physical GPUs.
+2. `hami-device-plugin` discovers and registers all eight whole GPUs.
+3. It connects to Kubelet's Device Plugin API and registers the configured resource name, `nvidia.com/gpu`.
+4. `deviceSplitCount: 10` makes each registered whole GPU contribute ten schedulable device IDs.
+5. Kubelet publishes `8 × 10 = 80` as the node's `nvidia.com/gpu` capacity.
+
+This came from the **HAMi device-plugin container log**, not from Kubelet or the NVIDIA GPU Operator:
+
+```bash
+PLUGIN_POD=$(kubectl get pod -n hami-system \
+  -l app.kubernetes.io/component=hami-device-plugin \
+  -o jsonpath='{.items[0].metadata.name}')
+
+kubectl logs -n hami-system "$PLUGIN_POD" -c device-plugin \
+  | grep -E 'Discovered [0-9]+ device\(s\) for registration' \
+  | tail -1
+I0723 09:53:36.227471 1910347 register.go:197] Discovered 8 device(s) for registration
+```
+
+The node's `hami.io/node-nvidia-register` annotation records `"count": 10` for each of those eight registered GPU UUIDs. The physical inventory and MIG state agree:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# nvidia-smi \
+  --query-gpu=index,name,mig.mode.current --format=csv,noheader
+0, NVIDIA RTX PRO 6000 Blackwell Server Edition, Disabled
+1, NVIDIA RTX PRO 6000 Blackwell Server Edition, Disabled
+2, NVIDIA RTX PRO 6000 Blackwell Server Edition, Disabled
+3, NVIDIA RTX PRO 6000 Blackwell Server Edition, Disabled
+4, NVIDIA RTX PRO 6000 Blackwell Server Edition, Disabled
+5, NVIDIA RTX PRO 6000 Blackwell Server Edition, Disabled
+6, NVIDIA RTX PRO 6000 Blackwell Server Edition, Disabled
+7, NVIDIA RTX PRO 6000 Blackwell Server Edition, Disabled
+```
+
+That is why the host has eight GPUs while this live HAMi registration contributes 80 logical slots. Without either HAMi's device plugin or NVIDIA's official device plugin, `nvidia-smi` could work perfectly on the host while Kubernetes would advertise **no** `nvidia.com/gpu` capacity.
+
+This also explains the conflict warning above: HAMi's plugin and NVIDIA's official plugin should not both try to own `nvidia.com/gpu` on the same node.
+
+The `nvcr.io/nvidia/pytorch:25.01-py3` image used later is an official NGC image. NVIDIA's [25.01 release notes](https://docs.nvidia.com/deeplearning/frameworks/pytorch-release-notes/rel-25-01.html) mark that release as optimized for Blackwell, and our test confirmed compute capability `(12, 0)` on this RTX PRO 6000.
+
+## How HAMi's Architecture Differs from the MIG Stack
+
+The MIG stack first creates hardware instances, then the NVIDIA device plugin advertises those instances to Kubernetes. HAMi leaves the physical GPU unpartitioned in `hami-core` mode and coordinates four software responsibilities instead: admission, placement, device injection, and in-container enforcement.
+
+![Excalidraw-style flow showing a HAMi request moving through the webhook, scheduler extender, device plugin, HAMi-Core, and physical GPU](/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-architecture.png)
+
+### HAMi mutating webhook
+
+When a pod requests HAMi-managed resources, the webhook routes it to `hami-scheduler`. It does **not** send every ordinary pod through HAMi. A CPU-only sanity-check pod on the rebuilt cluster retained `schedulerName: default-scheduler`, while the GPU test pods reported `schedulerName: hami-scheduler`.
+
+### `hami-scheduler` (cluster-wide)
+
+The HAMi scheduler pod contains a Kubernetes scheduler instance plus HAMi's extender logic. During **Filter**, it rejects nodes or cards that lack a free sharing slot, requested VRAM, or requested compute. During **Score**, it applies the configured binpack/spread policy. During **Bind**, it chooses a physical GPU UUID and records the allocation in pod annotations. The official [architecture documentation](https://project-hami.io/docs/core-concepts/architecture) describes these roles separately.
+
+### `hami-device-plugin` (DaemonSet, one per GPU node)
+
+Registers the logical GPU count with Kubelet, publishes each physical card's UUID/memory/core information in node annotations, and reads the scheduler's chosen allocation from the pod annotation. During the Device Plugin `Allocate` call it exposes `/dev/nvidia*`, mounts `libvgpu.so` and `/etc/ld.so.preload`, and injects limit variables into the container. Its `vgpu-monitor` sidecar exports real-time usage metrics; the OOM message itself is emitted by HAMi-Core inside the workload process.
+
+### `hami-core` (the actual enforcement mechanism)
+
+This is the shared library, `libvgpu.so`, that HAMi mounts into a managed NVIDIA workload container. `/etc/ld.so.preload` causes the dynamic linker to load it into processes before CUDA/NVML libraries. It intercepts supported calls used to allocate/query memory and throttles kernel launches for compute control. The [HAMi-Core design](https://project-hami.io/docs/developers/hami-core-design) places it between the CUDA runtime and driver.
+
+When a container's tracked allocation would exceed its configured `nvidia.com/gpumem` limit, HAMi-Core returns an OOM on that intercepted path even if the physical card still has free memory. This is also why `nvidia-smi` _inside_ a HAMi container reports its virtualized total instead of the card's real 97887 MiB: the relevant NVML memory query is intercepted too.
+
+Here is the mechanism from one of the fresh 8,000 MiB / 10% test containers:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl exec \
+  -n hami-blog-verify pytorch-hami-demo-77b6f5dcd9-whrbg -- \
+  sh -c 'cat /etc/ld.so.preload; printf "CUDA_DEVICE_MEMORY_LIMIT_0=%s\n" "$CUDA_DEVICE_MEMORY_LIMIT_0"; printf "CUDA_DEVICE_SM_LIMIT=%s\n" "$CUDA_DEVICE_SM_LIMIT"'
+/usr/local/vgpu/libvgpu.so
+CUDA_DEVICE_MEMORY_LIMIT_0=8000m
+CUDA_DEVICE_SM_LIMIT=10
+```
+
+No `runtimeClassName` appears in our pod because the node uses `nvidia-container-runtime` by default and this chart was installed with `devicePlugin.createRuntimeClass: false`. HAMi still depends on the NVIDIA Container Toolkit/runtime; omitting the field does not mean that layer is unnecessary.
+
+## What “80 GPUs” Means on an Eight-GPU Node
+
+This node advertises `nvidia.com/gpu: 80` even though `nvidia-smi -L` lists eight physical cards. The missing mental model is simple:
+
+- `deviceSplitCount: 10` means **up to ten separate workload containers may share one physical GPU**.
+- `nvidia.com/gpu: 1` means the container needs one physical GPU in its device set. It does not mean “one tenth of a GPU,” and a single container cannot request two logical slots from the same card by setting this to `2`.
+- `nvidia.com/gpumem` and `nvidia.com/gpucores` describe the per-GPU budget for that container.
+
+The arithmetic is `8 HAMi-registered whole GPUs × 10 possible sharing workloads = 80 schedulable GPU units`. The node still has only eight physical memory systems and eight sets of SMs.
+
+{{hami-slot-math-animation}}
+
+The chart defaults to 10, but the right value is a concurrency choice, not a performance promise. A smaller number reduces how many containers can contend on one card. A larger number permits more tiny workloads, but adds more contexts, more neighbors, and more operational complexity. Setting it to `1` restores exclusive placement: only one workload can occupy each physical GPU.
+
+With `deviceMemoryScaling: 1` and `deviceCoreScaling: 1`, the scheduler also checks the real aggregate budget. It does not admit a pod merely because a count slot is free. After deploying the two 8,000 MiB replicas in the next section, we prove this with a separate 90,000 MiB pod. Its complete manifest, commands, and captured `CardInsufficientMemory` event are included there.
+
+That scheduler decision is **not an OOM**: the rejected container never starts. A real runtime OOM happens when an admitted container allocates beyond its own grant. We reproduce that separately in [the blast-radius test](#testing-the-blast-radius-what-happens-when-a-pod-exceeds-its-memory-quota).
+
+The practical upside is density without fixed profile sizes. A notebook can request 8,000 MiB, a small inference replica 12,000 MiB, and another workload 20,000 MiB, as long as the total count, memory, and compute requests all fit. The practical costs are shared-hardware contention and a software isolation boundary, so latency-sensitive or adversarial tenants may still deserve MIG or dedicated GPUs.
+
+### Verify the count yourself
+
+The split factor appears in `hami.io/node-nvidia-register`, where each registered whole GPU has `"count": 10`. The simplest summary is the live node capacity:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl get node utho-gpu-rtxpro6000-8-62383 \
+  -o custom-columns='NAME:.metadata.name,KUBERNETES:.status.nodeInfo.kubeletVersion,GPU-CAPACITY:.status.capacity.nvidia\.com/gpu,GPU-ALLOCATABLE:.status.allocatable.nvidia\.com/gpu'
+NAME                          KUBERNETES   GPU-CAPACITY   GPU-ALLOCATABLE
+utho-gpu-rtxpro6000-8-62383   v1.35.6      80             80
+```
+
+The node's capacity confirms `8 × 10 = 80`, while `nvidia-smi -L` remains the source of truth for the eight-card physical inventory.
+
+## Reading the Helm Values That Control the Split
+
+The `count: 10` comes straight from the live Helm release's computed values. Here are only the fields that affect this walkthrough; the full output also contains image, service, security-context, and vendor configuration:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# helm get values -n hami-system hami --all
+```
+
+```yaml
+devicePlugin:
+  deviceSplitCount: 10
+  deviceMemoryScaling: 1
+  deviceCoreScaling: 1
+  migStrategy: none
+  disablecorelimit: "false"
+  createRuntimeClass: false
+  runtimeClassName: ""
+  nvidiaNodeSelector:
+    gpu: "on"
+resourceName: nvidia.com/gpu
+resourceMem: nvidia.com/gpumem
+resourceMemPercentage: nvidia.com/gpumem-percentage
+resourceCores: nvidia.com/gpucores
+scheduler:
+  defaultSchedulerPolicy:
+    gpuSchedulerPolicy: spread
+    nodeSchedulerPolicy: binpack
+```
+
+The current [HAMi configuration reference](https://project-hami.io/docs/userguide/configure) defines the semantics:
+
+- **`deviceSplitCount: 10`** is the maximum number of workload containers HAMi may assign to one physical GPU. `1` means exclusive placement, not fractional sharing.
+- **`deviceMemoryScaling: 1`** means the schedulable memory budget equals physical memory. Values above `1` deliberately advertise more memory than exists; HAMi documents memory overcommit as experimental, and a real physical OOM becomes possible if tenants use all promised memory together.
+- **`deviceCoreScaling: 1`** keeps the aggregate schedulable compute budget at 100% per card.
+- **`disablecorelimit: "false"`** enables HAMi-Core's compute limiting path. Core control is time-based throttling, so `nvidia-smi` utilization can fluctuate around the requested percentage rather than drawing a perfectly flat line.
+- **`migStrategy: none`** means HAMi is not layering on top of MIG partitions here; it's doing pure `hami-core` software slicing against whole physical GPUs.
+- **`nvidiaNodeSelector.gpu: "on"`** restricts the device plugin to nodes labeled `gpu=on`, which matches the label already on this node.
+- **`gpuSchedulerPolicy: spread`** prefers different physical cards; **`nodeSchedulerPolicy: binpack`** prefers already-used nodes. For the same-GPU isolation test, relying on a preference is not precise enough, so the manifest below pins a known idle GPU UUID.
+
+## How to Request vGPU Slices in a Pod Spec
+
+Where a MIG manifest requests a fixed profile (`nvidia.com/mig-1g.24gb: 1`), a HAMi manifest can request three independent values:
+
+One unit detail matters throughout the test: `gpumem` is measured in **MiB**. One MiB is 1,048,576 bytes, so 8,000 MiB is 8,388,608,000 bytes or 7.8125 GiB. That is why HAMi accepts `8000` while PyTorch later prints `7.81 GiB`; the numbers describe the same capacity.
+
+```yaml
+resources:
+  limits:
+    nvidia.com/gpu: 1 # use one physical GPU, possibly shared with other containers
+    nvidia.com/gpumem: 8000 # reserve and expose 8000 MiB on that GPU
+    nvidia.com/gpucores: 10 # request 10% of that GPU's compute time
+```
+
+Kubernetes extended resources belong in `limits`; if you also write `requests`, they must match. This manifest includes both explicitly.
+
+### The exact two-container test
+
+For an ordinary workload, let HAMi choose a card. For a blast-radius test, both replicas must share the **same** card, so I pinned them to idle GPU 5 with `nvidia.com/use-gpuuuid`. The additional `binpack` annotation states the intent, while the UUID makes the result deterministic. Replace the UUID for your node, or remove both annotations outside a test.
+
+I kept the workload out of the `hami-system` control-plane namespace:
+
+```bash
+kubectl create namespace hami-blog-verify
+```
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: pytorch-hami-demo
+  namespace: hami-blog-verify
+  labels:
+    app: pytorch-hami-demo
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: pytorch-hami-demo
+  template:
+    metadata:
+      labels:
+        app: pytorch-hami-demo
+      annotations:
+        # Test-only pin so both replicas definitely share GPU 5.
+        nvidia.com/use-gpuuuid: "GPU-04dc48d7-7048-aef5-ad36-f5db716e7668"
+        hami.io/gpu-scheduler-policy: "binpack"
+    spec:
+      containers:
+        - name: pytorch
+          image: nvcr.io/nvidia/pytorch:25.01-py3
+          command: ["python3", "-c"]
+          args:
+            - |
+              import torch
+              import time
+
+              print("=== CUDA vGPU Slice Diagnostics ===", flush=True)
+              print("CUDA Available:", torch.cuda.is_available(), flush=True)
+              if torch.cuda.is_available():
+                  print("Device Name:", torch.cuda.get_device_name(0), flush=True)
+                  print("Device Capability:", torch.cuda.get_device_capability(0), flush=True)
+                  print("CUDA Device Count:", torch.cuda.device_count(), flush=True)
+
+                  print("Allocating tensors and starting matrix math...", flush=True)
+                  device = torch.device("cuda")
+                  x = torch.randn(10000, 10000, device=device)
+                  y = torch.randn(10000, 10000, device=device)
+
+                  while True:
+                      z = torch.matmul(x, y)
+                      time.sleep(0.5)
+              else:
+                  print("ERROR: CUDA is not available!", flush=True)
+                  time.sleep(3600)
+          resources:
+            limits:
+              nvidia.com/gpu: 1
+              nvidia.com/gpumem: 8000
+              nvidia.com/gpucores: 10
+            requests:
+              nvidia.com/gpu: 1
+              nvidia.com/gpumem: 8000
+              nvidia.com/gpucores: 10
+```
+
+Apply it and wait for both replicas:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl apply -f pytorch-hami-demo.yaml
+deployment.apps/pytorch-hami-demo created
+
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl rollout status \
+  deployment/pytorch-hami-demo -n hami-blog-verify --timeout=180s
+deployment "pytorch-hami-demo" successfully rolled out
+```
+
+Read the startup logs:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl logs \
+  -n hami-blog-verify -l app=pytorch-hami-demo \
+  --prefix --tail=20 \
+  | grep -E 'CUDA Available|Device Name|Device Capability|CUDA Device Count'
+[pod/pytorch-hami-demo-77b6f5dcd9-whrbg/pytorch] CUDA Available: True
+[pod/pytorch-hami-demo-77b6f5dcd9-whrbg/pytorch] Device Name: NVIDIA RTX PRO 6000 Blackwell Server Edition
+[pod/pytorch-hami-demo-77b6f5dcd9-whrbg/pytorch] Device Capability: (12, 0)
+[pod/pytorch-hami-demo-77b6f5dcd9-whrbg/pytorch] CUDA Device Count: 1
+[pod/pytorch-hami-demo-77b6f5dcd9-wx677/pytorch] CUDA Available: True
+[pod/pytorch-hami-demo-77b6f5dcd9-wx677/pytorch] Device Name: NVIDIA RTX PRO 6000 Blackwell Server Edition
+[pod/pytorch-hami-demo-77b6f5dcd9-wx677/pytorch] Device Capability: (12, 0)
+[pod/pytorch-hami-demo-77b6f5dcd9-wx677/pytorch] CUDA Device Count: 1
+```
+
+Both placement annotations name GPU 5 and the same 8,000 MiB / 10% grant:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl get pods \
+  -n hami-blog-verify -l app=pytorch-hami-demo \
+  -o custom-columns='NAME:.metadata.name,ALLOCATION:.metadata.annotations.hami\.io/vgpu-devices-allocated'
+NAME                                 ALLOCATION
+pytorch-hami-demo-77b6f5dcd9-whrbg   GPU-04dc48d7-7048-aef5-ad36-f5db716e7668,NVIDIA,8000,10:;
+pytorch-hami-demo-77b6f5dcd9-wx677   GPU-04dc48d7-7048-aef5-ad36-f5db716e7668,NVIDIA,8000,10:;
+```
+
+Inside either container, `nvidia-smi` shows the virtualized view:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl exec \
+  -n hami-blog-verify pytorch-hami-demo-77b6f5dcd9-whrbg -- \
+  sh -c 'nvidia-smi --query-gpu=uuid,name,memory.total,memory.used --format=csv,noheader 2>/dev/null'
+GPU-04dc48d7-7048-aef5-ad36-f5db716e7668, NVIDIA RTX PRO 6000 Blackwell Server Edition, 8000 MiB, 2107 MiB
+```
+
+The host sees the two real processes on the same physical UUID:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# nvidia-smi \
+  --query-compute-apps=gpu_uuid,pid,used_memory --format=csv,noheader \
+  | grep 'GPU-04dc48d7-7048-aef5-ad36-f5db716e7668'
+GPU-04dc48d7-7048-aef5-ad36-f5db716e7668, 1932078, 2110 MiB
+GPU-04dc48d7-7048-aef5-ad36-f5db716e7668, 1932782, 2110 MiB
+```
+
+The few-MiB difference between in-container and host accounting is normal tool/accounting overhead. The important facts are the shared UUID and each container's separate 8,000 MiB view.
+
+### Prove that memory budget beats free count slots
+
+At this point, two of GPU 5's ten count slots are occupied. The allocation annotation proves that both 8,000 MiB reservations landed on the same physical card:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl get pods \
+  -n hami-blog-verify -l app=pytorch-hami-demo \
+  -o custom-columns='NAME:.metadata.name,ALLOCATION:.metadata.annotations.hami\.io/vgpu-devices-allocated'
+NAME                                 ALLOCATION
+pytorch-hami-demo-77b6f5dcd9-whrbg   GPU-04dc48d7-7048-aef5-ad36-f5db716e7668,NVIDIA,8000,10:;
+pytorch-hami-demo-77b6f5dcd9-wx677   GPU-04dc48d7-7048-aef5-ad36-f5db716e7668,NVIDIA,8000,10:;
+```
+
+Eight count slots are still free, but only `97,887 - 8,000 - 8,000 = 81,887 MiB` remains in HAMi's scheduling budget for that card. This third pod deliberately asks for 90,000 MiB:
+
+```yaml
+apiVersion: v1
+kind: Pod
+metadata:
+  name: hami-too-large
+  namespace: hami-blog-verify
+  annotations:
+    nvidia.com/use-gpuuuid: "GPU-04dc48d7-7048-aef5-ad36-f5db716e7668"
+spec:
+  restartPolicy: Never
+  containers:
+    - name: too-large
+      image: ubuntu:22.04
+      command: ["sleep", "3600"]
+      resources:
+        limits:
+          nvidia.com/gpu: 1
+          nvidia.com/gpumem: 90000
+          nvidia.com/gpucores: 10
+        requests:
+          nvidia.com/gpu: 1
+          nvidia.com/gpumem: 90000
+          nvidia.com/gpucores: 10
+```
+
+Apply it, inspect placement, and read only this pod's events:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl apply -f hami-too-large.yaml
+pod/hami-too-large created
+
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl get pod hami-too-large \
+  -n hami-blog-verify \
+  -o custom-columns='NAME:.metadata.name,STATUS:.status.phase,SCHEDULER:.spec.schedulerName,NODE:.spec.nodeName'
+NAME             STATUS    SCHEDULER        NODE
+hami-too-large   Pending   hami-scheduler   <none>
+
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl get events \
+  -n hami-blog-verify \
+  --field-selector involvedObject.name=hami-too-large \
+  --sort-by=.lastTimestamp
+LAST SEEN   TYPE      REASON             OBJECT               MESSAGE
+18s         Warning   FailedScheduling   pod/hami-too-large   0/1 nodes are available: 1 NodeUnfitPod. no new claims to deallocate, preemption: 0/1 nodes are available: 1 No preemption victims found for incoming pod.
+18s         Warning   FailedScheduling   pod/hami-too-large   0/1 nodes are available: 1 NodeUnfitPod. no new claims to deallocate, preemption: 0/1 nodes are available: 1 No preemption victims found for incoming pod.
+18s         Warning   FilteringFailed    pod/hami-too-large   1 nodes CardInsufficientMemory(utho-gpu-rtxpro6000-8-62383)
+18s         Warning   FilteringFailed    pod/hami-too-large   1 nodes CardUuidMismatch(utho-gpu-rtxpro6000-8-62383)
+18s         Warning   FilteringFailed    pod/hami-too-large   no available node, 1 nodes do not meet
+```
+
+The HAMi scheduler log makes the per-card result unambiguous:
+
+```bash
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl logs \
+  -n hami-system -l app.kubernetes.io/component=hami-scheduler \
+  -c vgpu-scheduler-extender --tail=2000 \
+  | grep '"NodeUnfitPod".*hami-too-large' | tail -1
+I0723 10:27:23.686479       1 score.go:169] "NodeUnfitPod" pod="hami-blog-verify/hami-too-large" node="utho-gpu-rtxpro6000-8-62383" reason="7/8 CardUuidMismatch, 1/8 CardInsufficientMemory"
+```
+
+The UUID mismatch is expected for the seven cards excluded by the explicit GPU 5 pin. The matching card's decisive result is `CardInsufficientMemory`: `90,000 + 8,000 + 8,000 = 106,000 MiB`, which exceeds its 97,887 MiB scheduling budget. The pod remains Pending and has no node because HAMi rejects it during scheduling. No container starts, so there is no CUDA or HAMi-Core OOM message in this test.
+
+### Fixed MiB or percentage?
+
+`nvidia.com/gpumem-percentage` requests a percentage of whichever card the scheduler chooses. HAMi's docs explicitly say not to combine it with fixed `gpumem`. On this 97,887 MiB card, a tested 50% memory request, paired with a separate 5% core request, produced:
+
+```text
+GPU-f4c61521-...,NVIDIA,48943,5:;
+GPU-f4c61521-..., 48943 MiB
+```
+
+Use fixed MiB when the application has a known memory requirement. Use a percentage when the intent is “half of any selected card” across a mixed-capacity fleet. The official [memory allocation guide](https://project-hami.io/docs/userguide/nvidia-device/specify-device-memory-usage) defines both forms.
+
+## How to Verify Where a Slice Landed
+
+With `deviceSplitCount: 10`, "my pod got a GPU" no longer tells you _which_ physical card. HAMi records its placement decision in pod annotations:
+
+```bash
+POD=$(kubectl get pods -n hami-blog-verify \
+  -l app=pytorch-hami-demo \
+  -o jsonpath='{.items[0].metadata.name}')
+
+kubectl get pod -n hami-blog-verify "$POD" -o json \
+  | jq '.metadata.annotations | with_entries(select(.key | test("hami|gpu"; "i")))'
+```
+
+The annotation to look for is `hami.io/vgpu-devices-allocated`. Its value encodes the physical GPU UUID, vendor, memory grant, and core grant for each allocated device. Our fresh test reported `GPU-04dc48d7-...,NVIDIA,8000,10:;`, which maps to GPU 5 in `nvidia-smi -L`.
+
+Two ways to cross-check that annotation against reality:
+
+- **From the host:** `nvidia-smi --query-compute-apps=gpu_uuid,pid,used_memory --format=csv` shows the physical UUID for each process. It should match the annotation.
+- **Across replicas:** compare both annotations. Same UUID means the containers share a card. For a deterministic test, use `nvidia.com/use-gpuuuid`; do not keep adding replicas and hope two collide.
+
+## Software Isolation vs. Hardware Isolation
+
+This is the tradeoff to internalize before using HAMi for multi-tenancy:
+
+![Excalidraw-style comparison of NVIDIA time-slicing, HAMi software quotas, and MIG hardware partitions](/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-isolation-spectrum.png)
+
+|                         | **NVIDIA time-slicing**                                                           | **HAMi (`hami-core`)**                                                                       | **MIG**                                                                          |
+| ----------------------- | --------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
+| Isolation boundary      | No per-replica GPU memory/compute boundary                                        | User-space interception through `libvgpu.so` and `/etc/ld.so.preload`                        | Hardware GPU instances with dedicated memory/compute resources                   |
+| Memory shape            | Every replica sees the whole card                                                 | 1 MiB request granularity                                                                    | Fixed profiles such as `1g.24gb` and `2g.48gb`                                   |
+| Compute shape           | Workloads take turns; no per-replica cap                                          | 1% request granularity, implemented through time-based throttling                            | Fixed fraction of SMs in the profile                                             |
+| What the container sees | Full physical GPU                                                                 | Virtual total equal to its grant                                                             | Its MIG device/profile                                                           |
+| Reconfiguration         | Change plugin config/redeploy affected pods                                       | Change the workload request                                                                  | Destroy/recreate affected instances; toggling mode may require a reset on Ampere |
+| Important limitation    | One workload can consume free VRAM needed by another workload's later allocations | Direct-driver paths, Docker-in-Docker, or `CUDA_DISABLE_CONTROL=true` can bypass enforcement | Requires supported GPU, driver, and profile geometry                             |
+
+Time-slicing does not automatically crash every neighbor when one process gets an OOM. The precise risk is that all replicas share the same physical memory pool without per-replica caps: one workload can consume the remaining VRAM, causing later allocations in other workloads to fail.
+
+Time-slicing shares access but does not give each pod a protected memory budget. HAMi adds software-enforced memory and compute quotas for supported CUDA workloads; in our PyTorch test, it stopped the container at its 8,000 MiB grant. The [HAMi troubleshooting guide](https://project-hami.io/docs/troubleshooting) documents paths that can bypass that user-space enforcement, so HAMi should be treated as resource control rather than a hard security boundary. MIG partitions supported GPUs in hardware, providing stronger isolation and more predictable performance, but with fixed profile sizes and more involved reconfiguration. For mutually untrusted tenants, combine MIG or a dedicated GPU with the VM or host isolation appropriate to your security model.
+
+## Testing the Blast Radius: What Happens When a Pod Exceeds Its Memory Quota
+
+With two replicas running, each holding an 8,000 MiB / 10% grant on the _same_ physical GPU, the question is straightforward: if one container allocates beyond 8,000 MiB, does only that allocation fail, or does the neighbor fail too?
+
+{{hami-blast-radius-animation}}
+
+This test covers a normal PyTorch/CUDA allocation path. It proves the configured quota for that path; it does not prove that user-space interception is impossible to bypass.
+
+### Step 1: Spike memory usage from inside the pod
+
+No need to change the Deployment. Exec into one replica and retain 20,000 × 20,000 FP32 tensors until HAMi-Core refuses the next allocation. Each tensor contains 400 million four-byte values: 1.6 GB in decimal units, or about 1.49 GiB.
+
+```bash
+POD=pytorch-hami-demo-77b6f5dcd9-whrbg
+
+kubectl exec -i -n hami-blog-verify "$POD" -- python3 - <<'PY'
+import torch
+
+tensors = []
+print(
+    f"Visible limit: {torch.cuda.get_device_properties(0).total_memory / 1024**2:.0f} MiB",
+    flush=True,
+)
+try:
+    for index in range(1, 9):
+        tensors.append(
+            torch.empty((20_000, 20_000), dtype=torch.float32, device="cuda")
+        )
+        torch.cuda.synchronize()
+        allocated = torch.cuda.memory_allocated() / 1024**2
+        print(f"block {index}: {allocated:.0f} MiB allocated", flush=True)
+except torch.OutOfMemoryError as error:
+    print("HAMi boundary reached: CUDA out of memory", flush=True)
+    print(str(error).split(". If reserved")[0], flush=True)
+PY
+```
+
+The main matmul process already held about 2.06 GiB, and the exec process shared the same container budget. The command returned:
+
+```text
+Visible limit: 8000 MiB
+[HAMI-core ERROR (pid:563 thread=134804753249792 allocator.c:52)]: Device 0 OOM 9185657856 / 8388608000
+[HAMI-core ERROR (pid:563 thread=134804753249792 allocator.c:52)]: Device 0 OOM 9185657856 / 8388608000
+block 1: 1526 MiB allocated
+block 2: 3052 MiB allocated
+block 3: 4578 MiB allocated
+HAMi boundary reached: CUDA out of memory
+CUDA out of memory. Tried to allocate 1.49 GiB. GPU 0 has a total capacity of 7.81 GiB of which 765.87 MiB is free. Process 1 has 2.06 GiB memory in use. Including non-PyTorch memory, this process has 5.01 GiB memory in use.
+```
+
+The two identical raw HAMi-Core lines came from the intercepted allocation path; the script then caught PyTorch's `OutOfMemoryError` and printed the readable summary. The first three new tensors succeeded. The fourth allocation would have pushed HAMi's tracked total to **9,185,657,856 bytes** against an **8,388,608,000-byte** limit, exactly 8,000 MiB. PyTorch sees 7.81 GiB because GiB uses powers of 1024. The card itself was nowhere near its 97,887 MiB physical limit, so this was a software quota verdict rather than a physical-card OOM.
+
+### Step 2: Check the offending container, neighbor, and host
+
+```bash
+# 1. Virtualized view inside the offending container.
+kubectl exec -n hami-blog-verify pytorch-hami-demo-77b6f5dcd9-whrbg -- \
+  nvidia-smi --query-gpu=uuid,memory.total,memory.used --format=csv
+
+# 2. Real processes and physical UUID from the host.
+nvidia-smi --query-compute-apps=gpu_uuid,pid,used_memory --format=csv
+
+# 3. Pod state and restart count for both replicas.
+kubectl get pods -n hami-blog-verify -l app=pytorch-hami-demo \
+  -o custom-columns='NAME:.metadata.name,STATUS:.status.phase,RESTARTS:.status.containerStatuses[0].restartCount'
+
+# 4. The neighbor's virtualized memory after the failed allocation.
+kubectl exec -n hami-blog-verify pytorch-hami-demo-77b6f5dcd9-wx677 -- \
+  sh -c 'nvidia-smi --query-gpu=uuid,memory.total,memory.used --format=csv,noheader 2>/dev/null'
+```
+
+The terminal view below shows the same virtual capacity and rejected allocation:
+
+![The pod's virtualized nvidia-smi pinned near its 8000MiB grant while hami-core rejects the next allocation](/img/blog/sharing-gpus-in-kubernetes-with-hami/oom-blast-radius.png)
+
+The fresh post-test checks returned:
+
+```text
+NAME                                 STATUS    RESTARTS
+pytorch-hami-demo-77b6f5dcd9-whrbg   Running   0
+pytorch-hami-demo-77b6f5dcd9-wx677   Running   0
+
+GPU-04dc48d7-7048-aef5-ad36-f5db716e7668, 8000 MiB, 2107 MiB
+```
+
+- **Offending container:** HAMi-Core returned OOM at its 8,000 MiB account boundary.
+- **Neighbor:** remained `Running`, had zero restarts, and still reported 2,107 MiB used of its own 8,000 MiB grant.
+- **Host:** showed both long-running processes on GPU 5. Physical memory headroom did not override the container limit.
+- **Application behavior:** this exec script catches the `RuntimeError`, so the pod stays alive. An uncaught OOM may terminate the process and trigger whatever restart policy the workload defines.
+
+The result is deliberately narrow and useful: **for this PyTorch/CUDA path, the memory overrun was contained to the offending container's allocation and the neighbor continued running.** The boundary is still a user-space contract, not a MIG hardware partition.
+
+## Monitoring the Slices
+
+A one-off test is not an operations strategy. HAMi exposes two Prometheus-format endpoints: one for allocation decisions and one for live usage. Prometheus/Grafana are still separate components if you want storage, alerting, and dashboards.
+
+Do not guess the ports from an old example. Check the Services installed by your chart:
+
+```text
+root@utho-gpu-rtxpro6000-8-62383:~# kubectl get service -n hami-system
+NAME                         TYPE       PORT(S)
+hami-device-plugin-monitor   NodePort   31992:31992/TCP
+hami-scheduler               NodePort   443:31998/TCP,31993:31993/TCP
+```
+
+**The scheduler's view:** cluster-wide allocation state, exposed by the `hami-scheduler` service (NodePort `31993` by default):
+
+```bash
+curl http://127.0.0.1:31993/metrics
+```
+
+This answers allocation questions: how much of each physical card's memory/core budget is promised (`hami_gpu_memory_allocated_bytes`, `hami_gpu_core_allocated_ratio`), how many containers share it (`hami_gpu_shared_count`), and which pods own each grant. With two 8,000 MiB / 10% containers on GPU 5, the scheduler endpoint reported an aggregate 16,000 MiB and 20% reservation:
+
+```text
+hami_gpu_core_allocated_ratio{device_index="5",device_uuid="GPU-04dc48d7-..."} 20
+hami_gpu_memory_allocated_bytes{device_cores="20",device_index="5",device_uuid="GPU-04dc48d7-..."} 1.6777216e+10
+```
+
+The official [cluster allocation metrics reference](https://project-hami.io/docs/userguide/monitoring/device-allocation) documents the metric names and labels.
+
+**The node's view:** real-time per-container usage, exposed by the `vgpu-monitor` sidecar through NodePort `31992` on this chart:
+
+```bash
+curl http://127.0.0.1:31992/metrics
+```
+
+This is the usage-side counterpart. For the unaffected neighbor, it reported about 2.21 GB used against an 8.39 GB byte limit:
+
+```text
+hami_container_device_memory_bytes{namespace="hami-blog-verify",pod="...-tj9rg"} 2.208433152e+09
+hami_vgpu_memory_limit_bytes{namespace="hami-blog-verify",pod="...-tj9rg"} 8.388608e+09
+```
+
+The current [real-time usage reference](https://project-hami.io/docs/userguide/monitoring/real-time-device-usage) lists host, container, memory, and utilization metrics. Alert on both dimensions: **allocated** tells you what the scheduler has promised; **used** tells you what applications actually consume.
+
+Wire both endpoints into Prometheus and a few panels give you the dashboard a shared-GPU platform actually needs. A useful layout keeps fleet capacity, per-pod grants, and per-GPU allocation visible together:
+
+![Grafana dashboard built from HAMi scheduler metrics: fleet stats, per-pod slices, and per-GPU allocation against the physical limit](/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-grafana-dashboard.png)
+
+The dashboard is useful because it keeps three different numbers separate: physical cards, logical sharing slots, and actual resource grants. Mixing those is how an eight-GPU node gets mistaken for an 80-GPU node.
+
+Once the outputs were captured, the temporary workloads were removed while the clean HAMi installation remained running:
+
+```bash
+kubectl delete namespace hami-blog-verify --wait=true
+```
+
+## Common Pitfalls and How to Solve Them
+
+### Pitfall A: Assuming `nvidia.com/gpu` Count Reflects Physical GPU Count
+
+The first time you see `nvidia.com/gpu: 80` on an 8-GPU node, it's easy to assume something is broken. Here, all eight whole GPUs are registered and each contributes ten logical slots. Check the `hami.io/node-nvidia-register` annotation before assuming a misconfiguration; the number of GPU entries and the `"count"` field per entry explain the capacity.
+
+### Pitfall B: Expecting `nvidia.com/gpu: 1` Alone to Mean “One Tenth”
+
+HAMi documents `nvidia.com/gpu` without memory/core fields as exclusive-GPU mode. I tested it on idle GPU 6; the allocation annotation was `GPU-f4f5db98-...,NVIDIA,97887,100:;`, and `nvidia-smi` inside the container reported all 97,887 MiB. If you intend to share, state `gpumem` and/or `gpucores` explicitly.
+
+### Pitfall C: Treating `requests` and `limits` Differently
+
+Kubernetes extended resources cannot be overcommitted like CPU. Put the HAMi resources in `limits`; if you include `requests`, use the same values. A mismatched manifest is rejected before HAMi can schedule it.
+
+### Pitfall D: Removing `runtimeClassName` Without Checking the Runtime
+
+Our manifest has no `runtimeClassName` because containerd's default is already `nvidia` and the HAMi chart did not create one. That is a property of this installation, not a universal copy/paste rule. A GPU Operator cluster may have `nvidia` or CDI-related RuntimeClasses, while an NRI-enabled Operator cluster may intentionally have none. Check `kubectl get runtimeclass`, `containerd config dump`, and your Operator mode before copying the field. A reference to a nonexistent runtime handler prevents the pod sandbox from starting.
+
+### Pitfall E: Blaming HAMi for a Slow First Deployment
+
+The NGC PyTorch image used above is a multi-gigabyte pull. On a fresh node, the pod will sit in `ContainerCreating` for several minutes while containerd downloads it, which looks a lot like a scheduling or webhook failure if you're watching for HAMi problems. `kubectl describe pod` disambiguates instantly: a `Pulling image` event means wait; a `FilteringFailed` event with `CardInsufficientMemory` means the selected card cannot fit the request alongside its existing tenants.
+
+### Pitfall F: Treating HAMi-Core Limits as Hardware-Equivalent to MIG
+
+As covered above, plan your multi-tenancy story around what `hami-core` actually demonstrated here (per-container quota enforcement through supported CUDA runtime and NVML paths), not around MIG's stronger silicon-level isolation. For adversarial or security-sensitive workloads, use MIG or dedicated GPUs together with the VM or host isolation required by your threat model.
+
+## Conclusion
+
+HAMi trades MIG's hardware boundary for flexibility: memory in 1 MiB units, compute in 1% steps, and limits that change with the workload spec instead of a hardware repartition.
+
+Here's what this setup walked through:
+
+1. Built a clean Kubernetes v1.35.6 node, configured the NVIDIA default runtime, and installed HAMi v2.9.0 as Helm revision 1.
+2. Traced the live `nvidia.com/gpu: 80` to eight registered whole GPUs with `deviceSplitCount: 10`, separating logical concurrency from physical capacity.
+3. Ran two fresh PyTorch replicas on one explicitly pinned GPU, each with an 8,000 MiB / 10% grant.
+4. Proved that an unfit 90,000 MiB request stayed Pending with `CardInsufficientMemory`, even though logical count slots remained.
+5. Reproduced HAMi-Core rejecting an attempted 9,185,657,856-byte total against an 8,388,608,000-byte grant while the neighboring container remained Running with zero restarts.
+6. Tested the two easy-to-misunderstand resource forms: GPU-only produced an exclusive 97,887 MiB / 100% allocation, and a 50% request produced 48,943 MiB.
+7. Queried the live allocation endpoint on `31993` and usage endpoint on `31992`, then checked the corresponding Grafana view.
+
+The payoff is fractional, self-service GPU access without pretending software quotas are silicon walls. For cooperative notebooks, CI jobs, and inference services, that can recover a great deal of stranded capacity. For strict QoS, choose MIG. For mutually untrusted tenants, pair MIG or dedicated GPUs with an appropriate VM or host boundary.
+
+HAMi is a CNCF Incubating project. The docs live at [project-hami.io](https://project-hami.io/) and the source at [github.com/Project-HAMi/HAMi](https://github.com/Project-HAMi/HAMi). For the hardware-isolation side of this story, continue with our [MIG deep dive](/blog/slicing-gpus-in-kubernetes-with-nvidia-mig).
diff --git a/lib/_blog-feed-data.js b/lib/_blog-feed-data.js
index 3bca9a9ed..a7ab36f38 100644
--- a/lib/_blog-feed-data.js
+++ b/lib/_blog-feed-data.js
@@ -1,5 +1,17 @@
 // AUTO-GENERATED by scripts/generate-feeds.mjs. Do not edit by hand.
 export const FEED_POSTS = [
+  {
+    "slug": "sharing-gpus-in-kubernetes-with-hami",
+    "title": "How to Share GPUs in Kubernetes at Scale with HAMi (Software vGPU Slicing)",
+    "description": "Share NVIDIA GPUs in Kubernetes with HAMi software vGPU slicing: memory and compute limits, Helm configuration, a verified PyTorch manifest, a real RTX PRO 6000 OOM test, and Prometheus monitoring.",
+    "datePublished": "2026-07-21T10:00:00.000Z",
+    "cover": "/img/blog/sharing-gpus-in-kubernetes-with-hami/cover.png",
+    "tags": [
+      "kubernetes",
+      "gpu",
+      "nvidia"
+    ]
+  },
   {
     "slug": "slicing-gpus-in-kubernetes-with-nvidia-mig",
     "title": "Slicing GPUs in Kubernetes with NVIDIA Multi-Instance GPU (MIG)",
@@ -343,17 +355,5 @@ export const FEED_POSTS = [
       "migration",
       "devops"
     ]
-  },
-  {
-    "slug": "clawspark-your-private-openclaw-ai-assistant-that-never-phones-home",
-    "title": "clawspark: Your Private OpenClaw AI Assistant That Never Phones Home",
-    "description": "Clawspark provides a way to Install openclaw on your device in a secure way with a single command. ",
-    "datePublished": "2026-03-15T15:37:37.104Z",
-    "cover": "/img/blog/clawspark-your-private-openclaw-ai-assistant-that-never-phones-home/fc9a8e16-4bcb-4bc8-a01e-46daf8c3fb7c.png",
-    "tags": [
-      "ollama",
-      "ai-assistants",
-      "ai-agent"
-    ]
   }
 ];
diff --git a/lib/markdown.js b/lib/markdown.js
index 486a63772..5b1db6b71 100644
--- a/lib/markdown.js
+++ b/lib/markdown.js
@@ -18,6 +18,9 @@ import Day5RuntimeStackAnimation from '@/components/Day5RuntimeStackAnimation';
 import Day5InferenceMetricsAnimation from '@/components/Day5InferenceMetricsAnimation';
 import Day5SpeculativeDecodingAnimation from '@/components/Day5SpeculativeDecodingAnimation';
 import Day5EngineChoiceAnimation from '@/components/Day5EngineChoiceAnimation';
+import HAMiBlastRadiusAnimation from '@/components/HAMiBlastRadiusAnimation';
+import HAMiRequestFlowAnimation from '@/components/HAMiRequestFlowAnimation';
+import HAMiSlotMathAnimation from '@/components/HAMiSlotMathAnimation';
 
 const BLOG_SHORTCODES = {
   '{{llm-request-animation}}': 'llm-request-animation',
@@ -31,6 +34,9 @@ const BLOG_SHORTCODES = {
   '{{day5-inference-metrics-animation}}': 'day5-inference-metrics-animation',
   '{{day5-speculative-decoding-animation}}': 'day5-speculative-decoding-animation',
   '{{day5-engine-choice-animation}}': 'day5-engine-choice-animation',
+  '{{hami-blast-radius-animation}}': 'hami-blast-radius-animation',
+  '{{hami-request-flow-animation}}': 'hami-request-flow-animation',
+  '{{hami-slot-math-animation}}': 'hami-slot-math-animation',
 };
 
 function remarkBlogShortcodes() {
@@ -97,6 +103,9 @@ const processor = unified()
       'day5-inference-metrics-animation': Day5InferenceMetricsAnimation,
       'day5-speculative-decoding-animation': Day5SpeculativeDecodingAnimation,
       'day5-engine-choice-animation': Day5EngineChoiceAnimation,
+      'hami-blast-radius-animation': HAMiBlastRadiusAnimation,
+      'hami-request-flow-animation': HAMiRequestFlowAnimation,
+      'hami-slot-math-animation': HAMiSlotMathAnimation,
     },
   });
 
diff --git a/public/_redirects b/public/_redirects
index b75470cab..d3caaa8cf 100644
--- a/public/_redirects
+++ b/public/_redirects
@@ -177,6 +177,7 @@
 /blog/quick-bites-of-fluxcd-health-assessment                                          /quick-bites-of-fluxcd-health-assessment  301!
 /blog/rancher-desktop-evolution                                                        /rancher-desktop-evolution  301!
 /blog/ready-for-wasm-day-2023                                                          /ready-for-wasm-day-2023  301!
+/blog/sharing-gpus-in-kubernetes-with-hami                                             /sharing-gpus-in-kubernetes-with-hami  301!
 /blog/simplified-introduction-to-bacalhau                                              /simplified-introduction-to-bacalhau  301!
 /blog/slicing-gpus-in-kubernetes-with-nvidia-mig                                       /slicing-gpus-in-kubernetes-with-nvidia-mig  301!
 /blog/speeding-up-using-microk8s                                                       /speeding-up-using-microk8s  301!
@@ -390,6 +391,7 @@
 /quick-bites-of-fluxcd-health-assessment                                          /blog/quick-bites-of-fluxcd-health-assessment  200!
 /rancher-desktop-evolution                                                        /blog/rancher-desktop-evolution  200!
 /ready-for-wasm-day-2023                                                          /blog/ready-for-wasm-day-2023  200!
+/sharing-gpus-in-kubernetes-with-hami                                             /blog/sharing-gpus-in-kubernetes-with-hami  200!
 /simplified-introduction-to-bacalhau                                              /blog/simplified-introduction-to-bacalhau  200!
 /slicing-gpus-in-kubernetes-with-nvidia-mig                                       /blog/slicing-gpus-in-kubernetes-with-nvidia-mig  200!
 /speeding-up-using-microk8s                                                       /blog/speeding-up-using-microk8s  200!
diff --git a/public/_worker.js b/public/_worker.js
index cb01a3463..83e943870 100644
--- a/public/_worker.js
+++ b/public/_worker.js
@@ -3,7 +3,7 @@
 // Replaces _redirects (Pages picks _worker.js over _redirects when both exist).
 
 const KUBESIMPLIFY_ROUTES = new Set(['/about', '/workshops', '/partnerships', '/resources']);
-const BLOG_SLUGS = new Set(["10-things-you-might-not-know-about-k9s","12-practical-grep-command-examples-in-linux","a-beginners-guide-to-dualbooting-windows-with-ubuntu-part-1","a-beginners-guide-to-dualbooting-windows-with-ubuntu-part-2","a-complete-walk-through-of-devops","a-kubeconfig-for-gke-that-doesnt-need-gcloud","a-simple-way-to-structure-your-terraform-code","a-simplified-guide-to-yaml","about-my-pdf-editor-project","an-overview-of-gitops-and-argocd","announcing-buildsafe","api-response-in-go","arkade","automate-repetitive-tasks-shell-scripting","automated-github-releases-with-github-actions-and-conventional-commits","avoid-overspending-with-kubecost","aws-elastic-cloud-compute","bake-your-container-images-with-bake","become-a-hashicorp-certified-terraform-associate-preparation-guide","best-devops-tools-2025","bonsai-27b-rtx-pro-6000-dgx-spark","breaking-down-docker","building-a-zero-cve-strategy","building-apigateway-with-lambda-using-pulumi","certified-kubernetes-security-specialist-cks-2022-exam-guide","cicd-pipeline-github-actions-with-aws-ecs","ckad-exam-april-2022","claude-code-leak-what-the-source-actually-teaches","clawspark-your-private-openclaw-ai-assistant-that-never-phones-home","cloud-computing","cloud-native-buildpacks-concepts","confidential-containers-running-on-kubernetes","container-and-kubernetes-security","controlling-mcp-tools-with-agentgateway-on-kubernetes","coolify","creating-multi-node-kubernetes-cluster-locally","day-1-the-local-llm-revolution-why-your-desk-just-became-the-new-datacenter","day-1-what-actually-happens-when-you-type-docker-run","day-2-anatomy-of-an-llm-inference-request-from-prompt-to-answer-step-by-step","day-2-your-images-are-a-supply-chain-and-it-s-probably-broken","day-3-stop-writing-dockerfiles-from-scratch","day-3-the-dgx-spark-unpacked-gb10-unified-memory-sm-121-and-the-one-reason-this-hardware-exists","day-4-breaking-isolation-on-purpose-volumes-networks-and-the-real-world","day-4-quantization-demystified-bf16-fp8-nvfp4-mxfp4-int4-gguf-and-why-it-all-matters","day-5-docker-compose-how-docker-actually-gets-used","day-5-local-llm-inference-engines-wrappers-and-what-to-pick","day-6-run-an-llm-on-your-laptop-with-docker","day-7-ship-it-and-what-comes-next","deploy-a-maven-project-on-a-tomcat-server-using-jenkins-and-aws","deploy-a-simple-server-using-aws-terraform","deploying-java-application-using-docker-and-kubernetes-devops-project","ditch-the-overheating-laptop-supercharge-your-docker-workflow-with-docker-offload","diy-how-to-build-a-kubernetes-policy-engine","docker-captain-journey","docker-mcp-catalog","docker-networking-demystified","embed-http-servers-in-wasm-with-rust-and-csharp","enhancing-runtime-security-with-falco-my-hands-on-experience","ephemeral-pull-request-environment-using-vcluster","essential-linux-commands-for-devops","event-driven-architecture-simplified-monolith-to-microservices","everything-you-need-to-know-about-docker-compose","everything-you-need-to-know-about-the-linux-ls-command","exploiting-metasploitable2-using-msfconsole-kali-linux-lab","firewall-a-networks-gatekeeper","four-pillars-of-observability-in-kubernetes","get-good-at-git","getting-started-with-kind-creating-a-multi-node-local-kubernetes-cluster","getting-started-with-ko-a-fast-container-image-builder-for-your-go-applications","getting-started-with-kyverno","git-and-github-a-beginners-guide","github-actions-101-what-are-github-actions-and-how-to-use-them-a-beginners-guide","gitops-demystified","ha-kubernetes","how-a-kubernetes-service-actually-works-and-all-5-types-you-need","how-get-started-with-hashicorp-vault","how-kubernetes-endpointslices-actually-work-and-why-endpoints-had-to-die","how-to-backup-kubernetes-with-kasten-community-edition","how-to-change-directory-in-shell-scripts","how-to-install-a-kubernetes-cluster-with-kubeadm-containerd-and-cilium-a-hands-on-guide","how-to-setup-your-ftp-server-in-linux","implementing-kubernetes-network-policies-a-comprehensive-guide","important-concepts-of-operating-systems","ing-switch-119-annotations-gateway-api-traefik-impact-ratings","ing-switch-migrate-from-ingress-nginx-to-traefik-or-gateway-api-in-minutes-not-days","installing-prometheus-with-selinux","introducing-kiac-kubernetes-in-apple-containers","introducing-unikraft-lightweight-virtualization-using-unikernels","introduction-of-jenkins-pipeline","introduction-to-cicd-and-cicd-pipeline","introduction-to-cri","introduction-to-developer-platforms-with-gimlet","introduction-to-helm","introduction-to-jenkins","introduction-to-kubernetes","introduction-to-terraform","iptables-demo","istio-service-mesh","k8sgpt-tutorial-when-kubernetes-meets-ai","keptn-getting-started","ksctl-making-kubernetes-easy-across-clouds","kube-proxy-deep-dive","kube-scheduler-deep-dive","kubecon-cloudnativecon-north-america-2024-recap-themes-innovations-and-community-spirit","kubecon-cloudnativecon-rejekts-and-wasm-io-wrap-up-a-leap-into-the-future-with-webassembly-ai-and-sustainable-cloud-practices","kubectl-run-nginx-inside","kubeflow-machine-learning-on-kubernetes-part-1","kubeflow-notebooks-ml-experimentation-made-easier-part-2","kubeflow-pipelines-orchestrating-machine-learning-workflows-part-3","kubernetes-125-dockerd","kubernetes-126","kubernetes-access-control-with-authentication-authorization-admission-control","kubernetes-adoption-key-challenges-in-migrating-to-kubernetes","kubernetes-backup-using-cloudcasa","kubernetes-containerd-setup","kubernetes-crio","kubernetes-management-with-rust-a-dive-into-generic-client-go-controller-abstractions-and-crd-macros-with-kubers","kubernetes-on-apple-macbooks-m-series","kubernetes-scheduling-the-complete-guide","kubernetes-v133-key-features-updates-and-what-you-need-to-know","kubernetes-v135-whats-new-whats-changing-and-what-you-should-know","kubesimplify-a-journey-to-remember","kubesimplify-at-wasmio-and-kubecon-eu-2024","kyverno-and-cosign","kyverno-cli","lets-learn-terraform","lets-simplify-golang-part-1","lets-simplify-golang-part-2","lets-simplify-golang-part-3","lets-talk-about-ansible","linux-boot-process-simplified","linux-system-directories-explained","llm-costs-and-observability-with-agentgateway-on-kubernetes","managing-contexts-in-kubernetes-with-plugins","managing-your-operating-system-with-package-managers","mastering-kubernetes-costs-from-monitoring-to-automation","microservices","mlxcel-rust-native-inference-engine-tested-on-m1-max","moving-code-between-git-repositories-with-copybara","multi-stage-docker-build","multi-tenancy-in-2025-and-beyond","my-first-international-conference-open-source-summit-2022","my-journey-to-kubestronaut-on-kubernetes-10th-birthday","my-kubecon-euvirtual-experience","my-schedule-for-kubecon-cloudnativecon-eu-2022","navigating-through-cncf-landscape","nemotron3-on-dgx-spark","networking-fundamentals-for-devops","nexus-repository-manager-what-is-it-and-how-to-configure-it-on-a-digital-ocean-droplet","nvcf-is-now-open-source-inside-nvidia-s-gpu-function-platform","operating-systems-101-essential-knowledge-for-devopssre-engineers","optimizing-kubernetes-costs-balancing-spot-and-on-demand-instances-with-topology-spread-constraints","optimizing-scalability-a-deep-dive-into-load-testing-with-locust-on-eks","package-managers-demystified","perform-crud-operations-on-kubernetes-using-golang","platform-engineering-demystified-navigating-the-basics","pods-in-kubernetes","practical-guide-to-kubernetes-api","progressive-rollouts-with-argo-cd-rollouts","prometheus-explained","pure-cilium-a-guide-for-local-load-balancing-and-bgp","quick-bites-of-fluxcd-health-assessment","rancher-desktop-evolution","ready-for-wasm-day-2023","simplified-introduction-to-bacalhau","slicing-gpus-in-kubernetes-with-nvidia-mig","speeding-up-using-microk8s","ssh-into-your-dgx-spark-from-anywhere-in-the-world-using-tailscale","starting-your-devops-journey-as-a-windows-user","statefulsets","supply-chain-security-using-slsa-part-1-fundamentals","supply-chain-security-using-slsa-part-2-the-framework","terraform-best-practices","testing-docker-ais-gordon-how-smart-is-it","the-complete-guide-to-the-dd-command-in-linux","the-secret-gems-behind-building-container-images-enter-buildkit-and-docker-buildx","the-ultimate-guide-to-audit-logging-in-kubernetes-from-setup-to-analysis","the-webassembly-course","tutorial-build-a-cloud-cost-monitoring-system-with-terraform-ansible-and-komiser","understanding-docker-desktop-all-in-one-platform-for-containers","understanding-etcd-in-kubernetes-a-beginners-guide","understanding-how-containers-work-behind-the-scenes","understanding-the-architecture-of-kubernetes-a-beginners-guide","understanding-the-ins-and-outs-of-git-using-github","wandler-local-openai-compatible-inference-transformersjs-webgpu","what-is-reproducibility-and-why-does-it-matter","what-is-shell-scripting","why-are-network-policies-in-kubernetes-so-hard-to-understand","why-devops-case-study","wtf-is-linux-shell-command-substitution","yours-kindly-drone"]);
+const BLOG_SLUGS = new Set(["10-things-you-might-not-know-about-k9s","12-practical-grep-command-examples-in-linux","a-beginners-guide-to-dualbooting-windows-with-ubuntu-part-1","a-beginners-guide-to-dualbooting-windows-with-ubuntu-part-2","a-complete-walk-through-of-devops","a-kubeconfig-for-gke-that-doesnt-need-gcloud","a-simple-way-to-structure-your-terraform-code","a-simplified-guide-to-yaml","about-my-pdf-editor-project","an-overview-of-gitops-and-argocd","announcing-buildsafe","api-response-in-go","arkade","automate-repetitive-tasks-shell-scripting","automated-github-releases-with-github-actions-and-conventional-commits","avoid-overspending-with-kubecost","aws-elastic-cloud-compute","bake-your-container-images-with-bake","become-a-hashicorp-certified-terraform-associate-preparation-guide","best-devops-tools-2025","bonsai-27b-rtx-pro-6000-dgx-spark","breaking-down-docker","building-a-zero-cve-strategy","building-apigateway-with-lambda-using-pulumi","certified-kubernetes-security-specialist-cks-2022-exam-guide","cicd-pipeline-github-actions-with-aws-ecs","ckad-exam-april-2022","claude-code-leak-what-the-source-actually-teaches","clawspark-your-private-openclaw-ai-assistant-that-never-phones-home","cloud-computing","cloud-native-buildpacks-concepts","confidential-containers-running-on-kubernetes","container-and-kubernetes-security","controlling-mcp-tools-with-agentgateway-on-kubernetes","coolify","creating-multi-node-kubernetes-cluster-locally","day-1-the-local-llm-revolution-why-your-desk-just-became-the-new-datacenter","day-1-what-actually-happens-when-you-type-docker-run","day-2-anatomy-of-an-llm-inference-request-from-prompt-to-answer-step-by-step","day-2-your-images-are-a-supply-chain-and-it-s-probably-broken","day-3-stop-writing-dockerfiles-from-scratch","day-3-the-dgx-spark-unpacked-gb10-unified-memory-sm-121-and-the-one-reason-this-hardware-exists","day-4-breaking-isolation-on-purpose-volumes-networks-and-the-real-world","day-4-quantization-demystified-bf16-fp8-nvfp4-mxfp4-int4-gguf-and-why-it-all-matters","day-5-docker-compose-how-docker-actually-gets-used","day-5-local-llm-inference-engines-wrappers-and-what-to-pick","day-6-run-an-llm-on-your-laptop-with-docker","day-7-ship-it-and-what-comes-next","deploy-a-maven-project-on-a-tomcat-server-using-jenkins-and-aws","deploy-a-simple-server-using-aws-terraform","deploying-java-application-using-docker-and-kubernetes-devops-project","ditch-the-overheating-laptop-supercharge-your-docker-workflow-with-docker-offload","diy-how-to-build-a-kubernetes-policy-engine","docker-captain-journey","docker-mcp-catalog","docker-networking-demystified","embed-http-servers-in-wasm-with-rust-and-csharp","enhancing-runtime-security-with-falco-my-hands-on-experience","ephemeral-pull-request-environment-using-vcluster","essential-linux-commands-for-devops","event-driven-architecture-simplified-monolith-to-microservices","everything-you-need-to-know-about-docker-compose","everything-you-need-to-know-about-the-linux-ls-command","exploiting-metasploitable2-using-msfconsole-kali-linux-lab","firewall-a-networks-gatekeeper","four-pillars-of-observability-in-kubernetes","get-good-at-git","getting-started-with-kind-creating-a-multi-node-local-kubernetes-cluster","getting-started-with-ko-a-fast-container-image-builder-for-your-go-applications","getting-started-with-kyverno","git-and-github-a-beginners-guide","github-actions-101-what-are-github-actions-and-how-to-use-them-a-beginners-guide","gitops-demystified","ha-kubernetes","how-a-kubernetes-service-actually-works-and-all-5-types-you-need","how-get-started-with-hashicorp-vault","how-kubernetes-endpointslices-actually-work-and-why-endpoints-had-to-die","how-to-backup-kubernetes-with-kasten-community-edition","how-to-change-directory-in-shell-scripts","how-to-install-a-kubernetes-cluster-with-kubeadm-containerd-and-cilium-a-hands-on-guide","how-to-setup-your-ftp-server-in-linux","implementing-kubernetes-network-policies-a-comprehensive-guide","important-concepts-of-operating-systems","ing-switch-119-annotations-gateway-api-traefik-impact-ratings","ing-switch-migrate-from-ingress-nginx-to-traefik-or-gateway-api-in-minutes-not-days","installing-prometheus-with-selinux","introducing-kiac-kubernetes-in-apple-containers","introducing-unikraft-lightweight-virtualization-using-unikernels","introduction-of-jenkins-pipeline","introduction-to-cicd-and-cicd-pipeline","introduction-to-cri","introduction-to-developer-platforms-with-gimlet","introduction-to-helm","introduction-to-jenkins","introduction-to-kubernetes","introduction-to-terraform","iptables-demo","istio-service-mesh","k8sgpt-tutorial-when-kubernetes-meets-ai","keptn-getting-started","ksctl-making-kubernetes-easy-across-clouds","kube-proxy-deep-dive","kube-scheduler-deep-dive","kubecon-cloudnativecon-north-america-2024-recap-themes-innovations-and-community-spirit","kubecon-cloudnativecon-rejekts-and-wasm-io-wrap-up-a-leap-into-the-future-with-webassembly-ai-and-sustainable-cloud-practices","kubectl-run-nginx-inside","kubeflow-machine-learning-on-kubernetes-part-1","kubeflow-notebooks-ml-experimentation-made-easier-part-2","kubeflow-pipelines-orchestrating-machine-learning-workflows-part-3","kubernetes-125-dockerd","kubernetes-126","kubernetes-access-control-with-authentication-authorization-admission-control","kubernetes-adoption-key-challenges-in-migrating-to-kubernetes","kubernetes-backup-using-cloudcasa","kubernetes-containerd-setup","kubernetes-crio","kubernetes-management-with-rust-a-dive-into-generic-client-go-controller-abstractions-and-crd-macros-with-kubers","kubernetes-on-apple-macbooks-m-series","kubernetes-scheduling-the-complete-guide","kubernetes-v133-key-features-updates-and-what-you-need-to-know","kubernetes-v135-whats-new-whats-changing-and-what-you-should-know","kubesimplify-a-journey-to-remember","kubesimplify-at-wasmio-and-kubecon-eu-2024","kyverno-and-cosign","kyverno-cli","lets-learn-terraform","lets-simplify-golang-part-1","lets-simplify-golang-part-2","lets-simplify-golang-part-3","lets-talk-about-ansible","linux-boot-process-simplified","linux-system-directories-explained","llm-costs-and-observability-with-agentgateway-on-kubernetes","managing-contexts-in-kubernetes-with-plugins","managing-your-operating-system-with-package-managers","mastering-kubernetes-costs-from-monitoring-to-automation","microservices","mlxcel-rust-native-inference-engine-tested-on-m1-max","moving-code-between-git-repositories-with-copybara","multi-stage-docker-build","multi-tenancy-in-2025-and-beyond","my-first-international-conference-open-source-summit-2022","my-journey-to-kubestronaut-on-kubernetes-10th-birthday","my-kubecon-euvirtual-experience","my-schedule-for-kubecon-cloudnativecon-eu-2022","navigating-through-cncf-landscape","nemotron3-on-dgx-spark","networking-fundamentals-for-devops","nexus-repository-manager-what-is-it-and-how-to-configure-it-on-a-digital-ocean-droplet","nvcf-is-now-open-source-inside-nvidia-s-gpu-function-platform","operating-systems-101-essential-knowledge-for-devopssre-engineers","optimizing-kubernetes-costs-balancing-spot-and-on-demand-instances-with-topology-spread-constraints","optimizing-scalability-a-deep-dive-into-load-testing-with-locust-on-eks","package-managers-demystified","perform-crud-operations-on-kubernetes-using-golang","platform-engineering-demystified-navigating-the-basics","pods-in-kubernetes","practical-guide-to-kubernetes-api","progressive-rollouts-with-argo-cd-rollouts","prometheus-explained","pure-cilium-a-guide-for-local-load-balancing-and-bgp","quick-bites-of-fluxcd-health-assessment","rancher-desktop-evolution","ready-for-wasm-day-2023","sharing-gpus-in-kubernetes-with-hami","simplified-introduction-to-bacalhau","slicing-gpus-in-kubernetes-with-nvidia-mig","speeding-up-using-microk8s","ssh-into-your-dgx-spark-from-anywhere-in-the-world-using-tailscale","starting-your-devops-journey-as-a-windows-user","statefulsets","supply-chain-security-using-slsa-part-1-fundamentals","supply-chain-security-using-slsa-part-2-the-framework","terraform-best-practices","testing-docker-ais-gordon-how-smart-is-it","the-complete-guide-to-the-dd-command-in-linux","the-secret-gems-behind-building-container-images-enter-buildkit-and-docker-buildx","the-ultimate-guide-to-audit-logging-in-kubernetes-from-setup-to-analysis","the-webassembly-course","tutorial-build-a-cloud-cost-monitoring-system-with-terraform-ansible-and-komiser","understanding-docker-desktop-all-in-one-platform-for-containers","understanding-etcd-in-kubernetes-a-beginners-guide","understanding-how-containers-work-behind-the-scenes","understanding-the-architecture-of-kubernetes-a-beginners-guide","understanding-the-ins-and-outs-of-git-using-github","wandler-local-openai-compatible-inference-transformersjs-webgpu","what-is-reproducibility-and-why-does-it-matter","what-is-shell-scripting","why-are-network-policies-in-kubernetes-so-hard-to-understand","why-devops-case-study","wtf-is-linux-shell-command-substitution","yours-kindly-drone"]);
 
 export default {
   async fetch(request, env) {
diff --git a/public/atom.xml b/public/atom.xml
index 3dcdc6089..85a74a750 100644
--- a/public/atom.xml
+++ b/public/atom.xml
@@ -5,11 +5,23 @@
   <link href="https://blog.kubesimplify.com/atom.xml" rel="self"/>
   <link href="https://blog.kubesimplify.com/"/>
   <id>https://blog.kubesimplify.com/</id>
-  <updated>2026-07-20T16:39:31.781Z</updated>
+  <updated>2026-07-22T08:43:06.924Z</updated>
   <author>
     <name>Kubesimplify</name>
     <email>hello@kubesimplify.com</email>
   </author>
+  <entry>
+    <title>How to Share GPUs in Kubernetes at Scale with HAMi (Software vGPU Slicing)</title>
+    <link href="https://blog.kubesimplify.com/sharing-gpus-in-kubernetes-with-hami"/>
+    <id>https://blog.kubesimplify.com/sharing-gpus-in-kubernetes-with-hami</id>
+    <updated>2026-07-21T10:00:00.000Z</updated>
+    <published>2026-07-21T10:00:00.000Z</published>
+    <summary>Share NVIDIA GPUs in Kubernetes with HAMi software vGPU slicing: memory and compute limits, Helm configuration, a verified PyTorch manifest, a real RTX PRO 6000 OOM test, and Prometheus monitoring.</summary>
+    <category term="kubernetes"/>
+    <category term="gpu"/>
+    <category term="nvidia"/>
+    <category term="platform-engineering"/>
+  </entry>
   <entry>
     <title>Slicing GPUs in Kubernetes with NVIDIA Multi-Instance GPU (MIG)</title>
     <link href="https://blog.kubesimplify.com/slicing-gpus-in-kubernetes-with-nvidia-mig"/>
diff --git a/public/img/blog/sharing-gpus-in-kubernetes-with-hami/cover.png b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/cover.png
new file mode 100644
index 000000000..5c9184582
Binary files /dev/null and b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/cover.png differ
diff --git a/public/img/blog/sharing-gpus-in-kubernetes-with-hami/cover.svg b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/cover.svg
new file mode 100644
index 000000000..1efadeffc
--- /dev/null
+++ b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/cover.svg
@@ -0,0 +1,41 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1200" height="630" viewBox="0 0 1200 630">
+<defs><clipPath id="hami-clip-0"><rect x="70" y="407" width="515" height="112" rx="7"/></clipPath><clipPath id="hami-clip-1"><rect x="720" y="95" width="390" height="420" rx="7"/></clipPath><clipPath id="hami-clip-2"><rect x="760" y="212" width="145" height="105" rx="7"/></clipPath><clipPath id="hami-clip-3"><rect x="925" y="212" width="145" height="105" rx="7"/></clipPath><clipPath id="hami-clip-4"><rect x="760" y="338" width="145" height="105" rx="7"/></clipPath><clipPath id="hami-clip-5"><rect x="925" y="338" width="145" height="105" rx="7"/></clipPath></defs>
+<rect width="1200" height="630" fill="#f8fafc"/>
+<text x="64" y="68" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="19" font-weight="800" fill="#5d8f00" text-anchor="start">KUBESIMPLIFY · GPU SHARING</text>
+<text x="64" y="158" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="52" font-weight="800" fill="#172033" text-anchor="start">Sharing GPUs in</text>
+<text x="64" y="216.24" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="52" font-weight="800" fill="#172033" text-anchor="start">Kubernetes with HAMi</text>
+<text x="64" y="292" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="22" font-weight="500" fill="#5c677d" text-anchor="start">Flexible memory and compute limits in software,</text>
+<text x="64" y="322.36" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="22" font-weight="500" fill="#5c677d" text-anchor="start">tested on an 8× RTX PRO 6000 Kubernetes node.</text>
+<path d="M -42.7 519.0 Q 12.5 463.3 70.8 408.0 M -30.8 518.5 Q 24.8 463.2 82.0 407.8 M -19.2 519.3 Q 36.5 463.1 93.0 407.1 M -9.0 518.3 Q 48.5 464.1 104.0 407.8 M 2.4 519.5 Q 58.8 462.9 113.7 406.4 M 12.3 518.9 Q 68.9 463.4 125.5 407.9 M 23.7 519.3 Q 79.0 462.2 135.1 407.5 M 35.1 518.6 Q 91.8 464.5 146.2 407.2 M 46.9 519.7 Q 103.2 464.1 157.7 406.1 M 57.0 519.1 Q 112.2 462.0 168.7 406.8 M 68.4 518.6 Q 122.6 464.0 179.0 406.1 M 78.4 518.8 Q 134.8 463.4 191.1 406.1 M 90.3 519.8 Q 145.2 463.6 202.4 407.3 M 100.9 518.3 Q 157.3 462.2 212.3 406.5 M 112.5 519.9 Q 167.6 464.4 224.9 407.7 M 123.2 518.9 Q 177.6 462.6 234.3 407.5 M 134.3 518.6 Q 188.7 462.8 245.4 406.3 M 144.4 519.5 Q 202.4 461.6 257.2 406.8 M 156.5 519.3 Q 210.5 462.7 268.0 406.0 M 167.3 519.1 Q 223.3 462.9 278.3 407.0 M 177.4 518.5 Q 234.4 461.6 290.9 407.6 M 188.4 518.4 Q 244.9 463.0 301.5 407.2 M 199.3 518.6 Q 257.4 463.7 312.0 407.5 M 210.2 519.5 Q 268.1 463.7 323.2 407.6 M 221.7 518.5 Q 278.8 464.0 333.8 407.3 M 232.4 519.2 Q 290.1 462.0 344.6 407.9 M 243.8 519.2 Q 299.2 463.1 355.2 407.6 M 254.1 519.6 Q 310.8 464.0 366.3 406.7 M 266.2 519.3 Q 321.0 464.4 378.5 407.7 M 276.9 519.7 Q 332.1 463.5 388.3 406.5 M 287.1 518.0 Q 344.0 461.6 400.1 407.4 M 298.5 519.7 Q 355.3 462.6 410.8 407.9 M 309.4 519.5 Q 367.0 463.5 421.9 406.4 M 320.6 518.5 Q 375.7 462.1 432.1 407.3 M 331.5 519.1 Q 386.9 461.9 444.1 406.4 M 342.2 518.5 Q 397.8 464.5 454.9 406.5 M 353.3 518.8 Q 409.9 463.2 466.4 406.6 M 364.2 519.4 Q 422.0 463.8 477.5 407.6 M 375.4 519.9 Q 432.2 464.2 488.4 406.3 M 387.5 519.1 Q 444.1 462.2 498.1 407.1 M 397.3 519.8 Q 453.5 461.8 510.3 406.9 M 408.1 520.0 Q 466.3 462.1 520.1 406.1 M 419.6 519.0 Q 475.9 461.8 532.6 407.4 M 431.5 519.0 Q 488.5 461.7 543.8 407.9 M 442.2 519.2 Q 498.8 464.4 554.8 406.8 M 452.9 519.3 Q 509.0 462.0 565.1 407.5 M 464.7 519.2 Q 520.6 462.2 575.3 407.7 M 475.6 519.7 Q 529.5 463.8 587.9 406.1 M 485.9 519.0 Q 543.1 464.2 597.2 407.5 M 496.0 518.7 Q 551.7 462.8 609.6 406.0 M 508.8 518.5 Q 565.0 464.4 619.2 407.3 M 518.2 519.1 Q 575.2 462.3 631.3 406.8 M 529.1 518.6 Q 585.8 464.3 641.9 407.6 M 540.7 519.3 Q 596.8 463.9 653.9 406.1 M 552.4 519.9 Q 609.1 463.3 664.6 406.9 M 563.4 519.2 Q 620.2 461.6 675.5 406.6 M 575.0 519.1 Q 629.7 463.6 685.1 406.7" stroke="#a5d8ff" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-0)" stroke-linecap="round"/>
+<path d="M 70.5 408.9 Q 327.6 405.1 585.5 407.5 M 586.0 406.1 Q 584.8 463.7 584.3 517.8 M 586.7 517.4 Q 324.6 521.9 70.2 517.7 M 68.1 520.7 Q 70.2 460.5 71.5 405.0" stroke="#1971c2" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 68.8 407.3 Q 327.4 408.1 585.4 406.4 M 585.6 407.3 Q 585.5 463.4 585.4 519.9 M 584.7 519.7 Q 327.6 520.3 69.8 517.9 M 69.2 519.8 Q 70.0 462.3 71.0 408.1" stroke="#1971c2" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="327" y="449" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="24" font-weight="800" fill="#1971c2" text-anchor="middle">8 physical GPUs  →  80 scheduling slots</text>
+<text x="327" y="488" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#5c677d" text-anchor="middle">slots multiply · hardware capacity does not</text>
+<path d="M 300.7 514.9 Q 509.0 305.0 720.4 95.7 M 310.9 515.5 Q 522.1 305.6 730.3 95.5 M 321.6 514.9 Q 530.8 305.8 742.1 94.3 M 333.4 515.2 Q 541.8 305.4 752.1 95.3 M 343.3 515.4 Q 552.8 303.6 764.7 95.4 M 354.7 515.9 Q 565.6 306.1 775.2 95.9 M 366.6 514.4 Q 577.1 306.1 786.5 94.4 M 377.2 514.2 Q 586.1 303.6 797.0 94.3 M 387.1 515.9 Q 598.2 305.7 808.2 94.3 M 398.1 515.5 Q 609.3 306.3 819.3 95.7 M 409.7 515.3 Q 619.6 304.1 829.1 94.4 M 420.7 516.0 Q 629.9 306.2 840.7 95.1 M 432.4 516.0 Q 643.1 305.1 851.5 95.2 M 442.6 515.9 Q 653.0 304.4 862.9 95.7 M 453.0 514.4 Q 664.8 305.1 873.8 94.1 M 464.3 515.7 Q 673.6 303.7 884.2 94.3 M 475.5 514.3 Q 685.1 304.3 896.0 95.4 M 486.5 515.3 Q 695.6 305.8 907.7 94.4 M 497.0 514.2 Q 706.7 305.4 917.8 94.1 M 508.6 515.3 Q 719.5 303.8 929.0 94.7 M 519.7 514.7 Q 728.9 304.4 940.4 94.6 M 530.5 515.8 Q 740.5 305.6 950.5 95.8 M 541.6 514.7 Q 751.6 305.8 961.3 94.0 M 554.0 515.0 Q 763.2 304.3 972.4 95.2 M 563.3 514.1 Q 773.8 305.3 983.8 95.4 M 574.9 515.8 Q 785.9 305.5 995.9 95.8 M 586.3 514.7 Q 794.8 303.8 1005.1 94.2 M 596.4 514.9 Q 806.7 304.3 1016.8 94.4 M 607.1 515.6 Q 817.5 305.2 1028.0 94.3 M 619.1 515.0 Q 829.5 305.9 1039.6 94.1 M 629.5 515.9 Q 840.9 306.3 1050.8 95.1 M 641.7 514.5 Q 852.5 303.7 1060.9 95.0 M 651.7 515.6 Q 860.6 305.4 1071.2 94.1 M 663.3 514.7 Q 873.0 304.2 1082.7 94.4 M 673.1 514.1 Q 883.4 306.2 1094.1 94.2 M 684.4 516.0 Q 894.4 303.6 1105.0 95.8 M 696.9 515.0 Q 907.0 303.8 1115.2 95.1 M 707.9 515.2 Q 915.8 303.8 1127.3 96.0 M 718.7 514.7 Q 929.0 304.3 1137.9 95.0 M 730.0 514.4 Q 938.2 304.4 1148.1 94.1 M 739.9 514.9 Q 951.3 304.0 1159.1 95.2 M 751.5 515.7 Q 959.8 304.5 1171.6 95.4 M 761.9 515.0 Q 971.0 303.6 1182.1 95.6 M 773.9 514.7 Q 983.4 303.5 1194.0 94.2 M 784.7 515.3 Q 992.6 303.6 1205.0 95.1 M 795.6 516.0 Q 1005.7 304.2 1215.3 94.0 M 806.7 514.5 Q 1017.4 304.2 1225.5 94.4 M 816.4 515.8 Q 1027.7 305.8 1236.9 95.3 M 827.1 515.1 Q 1036.8 305.4 1248.7 94.8 M 838.2 515.8 Q 1050.3 305.5 1259.7 95.8 M 849.5 515.9 Q 1061.0 305.9 1270.9 95.6 M 860.2 514.1 Q 1072.5 305.6 1281.2 95.5 M 873.0 514.4 Q 1080.9 305.7 1291.1 95.3 M 883.5 514.2 Q 1092.7 304.4 1302.8 95.1 M 894.9 514.6 Q 1105.2 306.0 1314.2 95.2 M 904.9 515.1 Q 1114.3 304.6 1324.9 95.8 M 915.0 515.7 Q 1126.8 305.1 1337.0 94.4 M 926.7 515.5 Q 1136.1 304.8 1347.0 94.4 M 937.3 514.4 Q 1147.1 305.3 1358.5 95.9 M 949.0 515.3 Q 1159.0 305.9 1368.7 95.1 M 959.2 515.4 Q 1169.6 304.5 1379.7 95.1 M 970.8 514.6 Q 1182.5 306.4 1391.7 95.7 M 981.4 514.3 Q 1193.3 304.4 1402.4 94.6 M 992.1 515.7 Q 1203.6 303.9 1412.9 95.6 M 1003.2 515.8 Q 1213.6 303.9 1424.6 95.5 M 1014.4 515.8 Q 1226.0 305.4 1434.3 95.6 M 1025.2 515.1 Q 1236.0 306.4 1446.0 94.8 M 1036.2 515.6 Q 1246.9 305.1 1456.4 94.9 M 1048.3 514.2 Q 1258.9 304.4 1468.8 94.5 M 1058.8 514.5 Q 1268.9 306.0 1478.7 95.2 M 1070.4 514.6 Q 1280.5 304.5 1490.4 95.7 M 1080.4 514.6 Q 1290.2 304.9 1501.7 94.3 M 1092.5 514.9 Q 1301.2 305.2 1511.1 94.5 M 1102.2 514.3 Q 1311.7 304.6 1522.7 94.9" stroke="#e9ecef" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-1)" stroke-linecap="round"/>
+<path d="M 719.0 95.2 Q 912.7 95.1 1111.7 93.8 M 1109.8 96.5 Q 1112.3 305.6 1110.9 514.5 M 1111.6 515.9 Q 915.2 513.4 719.3 514.8 M 719.2 514.5 Q 721.3 307.9 719.6 94.3" stroke="#495057" stroke-width="3" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 719.0 94.0 Q 916.5 94.9 1111.0 95.4 M 1111.2 95.7 Q 1108.3 306.3 1109.8 514.5 M 1109.9 514.6 Q 916.2 514.9 720.6 513.9 M 720.2 515.9 Q 718.7 305.9 721.0 95.7" stroke="#495057" stroke-width="1.6500000000000001" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="915" y="138" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="26" font-weight="800" fill="#172033" text-anchor="middle">one physical GPU</text>
+<text x="915" y="170" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="20" font-weight="500" fill="#5c677d" text-anchor="middle">97,887 MiB</text>
+<path d="M 655.8 317.3 Q 707.1 265.6 760.9 211.8 M 666.8 316.6 Q 720.0 265.5 771.4 211.0 M 676.2 316.7 Q 730.0 263.6 782.1 211.2 M 688.3 317.2 Q 740.3 264.2 792.6 212.4 M 699.0 317.9 Q 751.1 265.9 803.8 211.4 M 709.3 316.6 Q 763.6 265.1 814.5 212.7 M 721.1 316.9 Q 772.2 264.0 826.0 211.8 M 732.7 316.1 Q 783.5 264.8 837.9 211.1 M 743.1 317.0 Q 795.0 264.2 847.9 212.9 M 754.3 316.8 Q 807.8 263.8 859.6 211.7 M 764.6 316.8 Q 818.1 265.5 869.5 211.2 M 776.9 317.6 Q 827.6 263.1 881.7 212.9 M 786.9 317.0 Q 839.9 265.1 892.3 211.2 M 798.1 317.7 Q 850.7 264.9 902.9 211.2 M 808.5 316.4 Q 862.1 264.1 914.3 211.4 M 819.2 316.2 Q 872.1 264.6 925.9 211.3 M 831.0 316.1 Q 883.0 265.8 936.0 212.2 M 841.0 316.4 Q 894.4 263.9 947.0 212.1 M 852.5 316.6 Q 905.1 263.2 957.8 211.2 M 863.8 317.5 Q 917.2 265.6 969.4 212.1 M 875.5 316.6 Q 926.6 263.1 980.8 211.1 M 885.4 316.1 Q 939.9 264.5 991.2 212.2 M 896.0 316.7 Q 950.1 264.3 1002.8 211.4" stroke="#d8f5a2" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-2)" stroke-linecap="round"/>
+<path d="M 760.6 211.7 Q 835.1 211.1 903.3 211.1 M 904.4 211.6 Q 902.5 263.8 904.2 318.5 M 904.8 316.5 Q 833.7 317.0 759.6 316.8 M 759.6 317.9 Q 760.4 264.9 759.1 213.3" stroke="#5d8f00" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 759.1 212.8 Q 831.3 213.4 905.2 212.8 M 905.2 212.9 Q 904.2 263.4 905.0 316.1 M 905.8 317.9 Q 833.1 315.5 758.8 316.8 M 760.9 317.9 Q 758.9 265.0 759.8 212.3" stroke="#5d8f00" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="832.5" y="247" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="19" font-weight="800" fill="#5d8f00" text-anchor="middle">pod 1</text>
+<text x="832.5" y="279" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="17" font-weight="500" fill="#172033" text-anchor="middle">8 GB · 10%</text>
+<path d="M 819.5 316.5 Q 873.8 265.5 925.2 212.3 M 830.3 316.6 Q 884.2 263.0 936.4 212.9 M 842.4 316.7 Q 894.9 265.1 947.8 212.0 M 853.3 316.9 Q 905.9 264.2 957.6 211.7 M 864.1 317.4 Q 916.0 263.0 968.6 212.9 M 875.8 317.6 Q 928.8 263.2 981.0 212.2 M 886.9 316.7 Q 938.0 264.2 991.8 212.5 M 896.1 316.9 Q 950.8 263.0 1002.2 212.4 M 908.5 316.9 Q 960.2 265.5 1012.4 212.7 M 919.2 317.6 Q 972.4 264.8 1023.4 212.6 M 929.1 316.0 Q 983.3 263.0 1034.5 211.9 M 941.9 316.7 Q 993.0 265.3 1046.2 211.7 M 951.5 317.8 Q 1004.0 265.4 1057.4 211.4 M 962.7 317.4 Q 1014.9 265.2 1067.6 212.4 M 973.1 317.5 Q 1025.2 264.4 1078.9 212.4 M 985.4 317.3 Q 1038.7 265.2 1089.0 212.3 M 996.4 317.0 Q 1049.8 265.3 1101.1 211.2 M 1007.0 317.4 Q 1060.1 264.1 1111.8 212.4 M 1017.8 316.4 Q 1070.2 265.9 1122.6 212.5 M 1029.6 317.6 Q 1080.3 263.6 1133.4 212.0 M 1039.8 317.9 Q 1092.0 263.4 1145.9 211.7 M 1050.1 317.9 Q 1102.4 265.3 1155.6 211.8 M 1062.0 317.2 Q 1114.7 263.9 1166.3 212.5" stroke="#a5d8ff" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-3)" stroke-linecap="round"/>
+<path d="M 923.0 211.2 Q 999.5 214.5 1068.8 211.3 M 1069.2 214.0 Q 1072.3 262.3 1071.6 316.6 M 1069.0 317.5 Q 996.5 314.3 923.5 317.8 M 925.6 316.9 Q 927.5 262.2 924.9 213.0" stroke="#1971c2" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 924.3 212.1 Q 999.1 212.0 1070.6 210.9 M 1068.9 211.2 Q 1071.5 265.9 1070.9 318.0 M 1070.7 315.9 Q 997.6 318.1 925.6 317.3 M 926.1 316.9 Q 924.3 265.3 924.7 212.8" stroke="#1971c2" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="997.5" y="247" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="19" font-weight="800" fill="#1971c2" text-anchor="middle">pod 2</text>
+<text x="997.5" y="279" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="17" font-weight="500" fill="#172033" text-anchor="middle">12 GB · 20%</text>
+<path d="M 654.9 443.7 Q 707.3 390.9 759.7 337.5 M 666.7 443.3 Q 717.9 391.3 771.1 337.4 M 677.9 442.2 Q 728.4 389.9 782.3 338.6 M 688.9 442.0 Q 740.9 390.9 792.9 337.6 M 698.0 442.6 Q 751.1 391.6 803.4 337.1 M 709.8 443.7 Q 762.1 389.2 814.6 338.5 M 720.6 442.0 Q 772.4 389.6 826.7 337.6 M 732.3 442.5 Q 784.3 391.8 837.3 337.1 M 743.6 442.2 Q 794.4 389.7 847.7 338.8 M 755.0 443.9 Q 806.1 389.7 858.3 338.1 M 765.7 443.3 Q 816.5 390.6 869.7 338.4 M 776.2 442.8 Q 827.1 390.5 880.5 337.6 M 787.6 442.5 Q 839.5 391.1 893.0 338.5 M 797.1 443.3 Q 850.2 390.6 903.9 337.5 M 808.6 442.8 Q 861.8 390.0 914.4 338.1 M 820.0 443.6 Q 871.2 391.6 925.4 338.8 M 831.5 443.0 Q 882.9 389.2 936.2 338.9 M 841.6 443.4 Q 894.5 390.0 946.9 337.6 M 852.2 443.5 Q 905.7 390.6 957.0 337.3 M 863.3 442.8 Q 916.9 391.5 969.4 337.1 M 874.0 442.6 Q 927.3 389.3 980.3 337.7 M 885.2 443.3 Q 938.5 389.0 991.6 337.2 M 897.8 443.0 Q 948.2 391.3 1002.8 337.1" stroke="#ffd8a8" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-4)" stroke-linecap="round"/>
+<path d="M 758.6 338.7 Q 831.9 338.8 903.1 338.6 M 905.3 337.2 Q 903.3 391.0 903.3 443.4 M 903.9 443.0 Q 833.1 442.7 758.4 442.7 M 760.7 444.5 Q 759.6 388.2 761.7 337.2" stroke="#d9480f" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 759.0 337.5 Q 831.5 337.0 905.9 336.8 M 904.4 338.7 Q 904.8 391.5 905.3 442.0 M 905.1 443.0 Q 832.2 444.2 760.7 443.2 M 759.4 443.9 Q 761.0 390.2 759.8 337.2" stroke="#d9480f" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="832.5" y="373" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="19" font-weight="800" fill="#d9480f" text-anchor="middle">pod 3</text>
+<text x="832.5" y="405" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="17" font-weight="500" fill="#172033" text-anchor="middle">20 GB · 25%</text>
+<path d="M 819.7 443.9 Q 871.2 391.9 924.7 338.8 M 831.4 443.4 Q 884.2 389.6 936.3 338.9 M 841.9 442.7 Q 894.8 390.7 947.1 337.1 M 852.5 443.2 Q 905.3 392.0 957.9 338.5 M 863.7 442.0 Q 916.4 390.8 968.4 337.0 M 875.2 442.6 Q 927.7 389.8 980.8 338.4 M 885.7 443.4 Q 938.9 390.3 990.9 337.2 M 897.0 442.5 Q 949.0 390.4 1001.6 337.2 M 907.9 442.5 Q 961.7 389.8 1013.8 338.7 M 918.6 442.4 Q 971.7 391.6 1023.5 338.9 M 930.1 443.7 Q 981.7 390.1 1035.8 338.0 M 941.9 443.5 Q 994.1 391.5 1045.9 338.4 M 951.0 442.9 Q 1005.1 391.6 1056.1 337.2 M 962.0 442.7 Q 1016.3 389.4 1067.5 338.5 M 974.9 443.0 Q 1026.5 389.2 1078.1 337.3 M 984.8 443.2 Q 1037.0 389.3 1090.9 338.5 M 995.8 442.3 Q 1048.9 389.3 1101.9 338.4 M 1006.6 442.9 Q 1059.0 391.5 1111.2 338.8 M 1018.7 442.8 Q 1069.2 390.1 1122.8 338.9 M 1029.7 443.0 Q 1080.9 391.5 1133.6 337.1 M 1040.1 442.5 Q 1093.2 391.9 1145.9 337.4 M 1050.0 443.7 Q 1104.1 390.9 1155.4 338.7 M 1062.7 442.8 Q 1114.5 390.1 1167.6 337.2" stroke="#eebefa" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-5)" stroke-linecap="round"/>
+<path d="M 924.8 336.4 Q 998.6 338.5 1068.8 338.9 M 1071.2 338.0 Q 1068.7 391.8 1068.9 443.4 M 1068.7 443.5 Q 998.7 442.9 926.8 442.4 M 925.1 443.6 Q 925.4 390.5 923.7 338.0" stroke="#862e9c" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 924.5 338.9 Q 996.9 336.7 1069.6 336.9 M 1070.9 337.3 Q 1069.0 389.5 1069.0 443.0 M 1069.5 443.5 Q 996.1 441.4 925.2 443.7 M 925.7 442.9 Q 925.2 390.7 926.0 337.7" stroke="#862e9c" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="997.5" y="373" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="19" font-weight="800" fill="#862e9c" text-anchor="middle">pod 4</text>
+<text x="997.5" y="405" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="17" font-weight="500" fill="#172033" text-anchor="middle">40 GB · 45%</text>
+<text x="915" y="487" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#5c677d" text-anchor="middle">software-enforced boundaries</text>
+<text x="64" y="588" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="700" fill="#d9480f" text-anchor="start">HAMi v2.9.0 · real commands · real OOM test</text>
+</svg>
\ No newline at end of file
diff --git a/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-architecture.png b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-architecture.png
new file mode 100644
index 000000000..26fc8d0b8
Binary files /dev/null and b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-architecture.png differ
diff --git a/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-architecture.svg b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-architecture.svg
new file mode 100644
index 000000000..0e65496c8
--- /dev/null
+++ b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-architecture.svg
@@ -0,0 +1,104 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1600" height="920" viewBox="0 0 1600 920">
+<defs><clipPath id="hami-clip-0"><rect x="65" y="170" width="245" height="205" rx="7"/></clipPath><clipPath id="hami-clip-1"><rect x="375" y="170" width="245" height="205" rx="7"/></clipPath><clipPath id="hami-clip-2"><rect x="685" y="170" width="245" height="205" rx="7"/></clipPath><clipPath id="hami-clip-3"><rect x="995" y="170" width="245" height="205" rx="7"/></clipPath><clipPath id="hami-clip-4"><rect x="995" y="510" width="245" height="205" rx="7"/></clipPath><clipPath id="hami-clip-5"><rect x="685" y="510" width="245" height="205" rx="7"/></clipPath><clipPath id="hami-clip-6"><rect x="375" y="510" width="245" height="205" rx="7"/></clipPath><clipPath id="hami-clip-7"><rect x="65" y="510" width="245" height="205" rx="7"/></clipPath><clipPath id="hami-clip-8"><rect x="1285" y="178" width="255" height="190" rx="7"/></clipPath><clipPath id="hami-clip-9"><rect x="1285" y="520" width="255" height="190" rx="7"/></clipPath></defs>
+<rect width="1600" height="920" fill="#ffffff"/>
+<text x="800" y="62" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="42" font-weight="800" fill="#172033" text-anchor="middle">What happens to one HAMi GPU request?</text>
+<text x="800" y="100" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="22" font-weight="500" fill="#5c677d" text-anchor="middle">placement first · injection second · enforcement while the process runs</text>
+<path d="M -139.3 374.5 Q -38.7 273.1 65.2 169.5 M -129.9 374.0 Q -25.9 271.5 75.5 170.3 M -117.8 374.2 Q -14.6 273.6 87.8 170.9 M -106.3 375.9 Q -3.2 271.3 97.5 169.0 M -95.7 376.0 Q 7.4 272.0 108.3 170.1 M -84.6 374.1 Q 18.5 273.4 119.1 170.6 M -74.1 374.6 Q 28.9 271.8 130.9 170.2 M -62.3 374.0 Q 39.7 273.4 141.8 171.0 M -51.7 374.6 Q 49.8 271.9 152.6 170.3 M -40.6 375.6 Q 60.6 271.0 165.0 170.6 M -29.9 374.1 Q 72.6 271.4 175.0 170.4 M -19.4 374.9 Q 85.0 271.3 187.0 170.0 M -7.3 375.2 Q 93.8 271.1 196.2 169.7 M 3.0 375.8 Q 104.9 271.1 207.4 170.5 M 14.5 374.3 Q 116.2 271.9 219.0 170.2 M 25.3 374.2 Q 127.5 273.1 230.0 170.7 M 36.7 374.5 Q 137.1 272.5 241.8 170.7 M 47.6 375.0 Q 150.4 271.5 252.9 170.5 M 57.3 375.3 Q 161.2 271.4 262.8 169.7 M 69.2 374.6 Q 171.2 273.7 273.1 169.0 M 79.8 375.8 Q 183.9 273.3 285.3 170.9 M 91.8 375.3 Q 193.5 272.2 296.2 170.2 M 102.2 375.5 Q 205.0 271.1 307.2 169.7 M 113.9 374.1 Q 214.9 272.7 318.3 169.1 M 123.9 375.7 Q 227.2 271.3 328.2 170.9 M 135.0 375.8 Q 238.2 273.0 339.9 169.8 M 146.7 375.3 Q 247.7 272.6 351.2 169.7 M 156.0 374.1 Q 260.9 273.6 362.4 169.1 M 167.8 375.3 Q 270.7 273.2 373.4 169.8 M 178.7 374.6 Q 280.4 272.1 384.3 170.3 M 190.8 375.8 Q 291.1 272.6 395.2 170.1 M 200.2 374.6 Q 303.3 272.2 406.9 170.9 M 211.5 375.9 Q 313.5 272.8 417.1 170.9 M 222.1 375.7 Q 327.0 271.1 427.4 170.9 M 234.3 374.4 Q 335.9 271.8 439.1 169.9 M 245.1 375.7 Q 346.7 271.5 450.9 169.3 M 255.8 375.3 Q 359.3 272.5 460.0 169.8 M 266.8 374.1 Q 368.7 273.9 471.6 170.1 M 277.1 375.4 Q 379.0 272.5 483.7 170.8 M 288.3 374.9 Q 390.5 273.1 493.7 170.5 M 299.9 374.9 Q 403.6 272.4 505.9 169.9" stroke="#a5d8ff" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-0)" stroke-linecap="round"/>
+<path d="M 64.0 168.5 Q 184.9 172.3 310.6 170.0 M 310.7 171.7 Q 310.9 272.1 309.9 374.2 M 310.9 373.3 Q 186.1 372.3 66.8 374.2 M 64.7 374.9 Q 66.0 272.5 66.9 169.2" stroke="#1971c2" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 65.9 170.4 Q 189.1 170.7 309.7 170.5 M 309.3 170.8 Q 309.8 272.1 310.8 375.0 M 309.3 373.9 Q 187.0 376.6 64.4 375.5 M 65.1 376.1 Q 65.0 271.6 65.4 170.6" stroke="#1971c2" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="187" y="212" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="23" font-weight="800" fill="#1971c2" text-anchor="middle">1. Pod spec</text>
+<text x="187" y="258" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">gpu: 1</text>
+<text x="187" y="282.3" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">gpumem: 8000</text>
+<text x="187" y="306.6" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">gpucores: 10</text>
+<path d="M 317.7 271.9 Q 340.5 269.4 364.1 271.7" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 364.2 270.7 Q 361.8 278.1 352.4 279.4" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 363.3 272.7 Q 360.4 269.9 351.7 263.1" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 169.3 375.5 Q 272.3 273.3 375.4 170.0 M 180.4 375.4 Q 283.4 272.0 386.8 169.7 M 192.0 374.7 Q 294.3 272.0 397.1 170.1 M 202.9 375.5 Q 304.4 271.9 408.2 170.9 M 213.6 374.7 Q 317.9 271.5 419.0 169.1 M 225.9 375.6 Q 326.8 272.1 429.2 170.2 M 235.6 374.1 Q 338.3 273.8 440.3 170.3 M 246.0 374.4 Q 349.4 273.9 452.2 169.4 M 257.9 374.9 Q 361.9 272.6 462.4 170.0 M 270.0 374.9 Q 372.5 272.0 474.8 170.8 M 279.5 375.5 Q 382.0 272.7 484.2 169.5 M 291.7 375.2 Q 393.0 271.3 495.9 170.9 M 302.3 374.6 Q 403.9 271.8 507.7 169.6 M 313.5 375.6 Q 416.9 272.5 518.9 170.8 M 323.2 374.3 Q 425.5 273.4 528.8 169.0 M 334.2 374.6 Q 436.3 271.5 539.9 170.3 M 346.7 375.9 Q 449.4 273.2 550.7 169.4 M 356.7 374.6 Q 460.7 272.2 561.2 170.7 M 368.2 375.1 Q 471.4 273.6 573.1 170.1 M 378.5 375.7 Q 480.9 271.4 583.2 169.6 M 390.9 374.4 Q 493.6 273.9 595.0 169.6 M 401.6 374.5 Q 504.9 271.1 606.7 169.6 M 412.3 374.1 Q 514.4 273.4 616.7 169.7 M 422.9 375.0 Q 524.4 272.4 627.3 169.3 M 433.8 375.3 Q 535.9 272.8 638.4 170.0 M 444.0 374.9 Q 546.3 273.7 650.4 169.4 M 455.0 375.6 Q 557.4 271.4 660.9 169.2 M 467.4 375.0 Q 570.5 271.2 672.3 170.5 M 478.4 375.1 Q 580.5 271.7 682.1 170.9 M 489.4 374.2 Q 592.7 273.4 693.9 170.0 M 499.3 374.2 Q 603.6 272.9 705.4 169.5 M 511.8 374.4 Q 613.6 271.3 715.4 169.5 M 521.2 375.6 Q 625.8 273.3 726.2 169.8 M 533.4 375.6 Q 635.7 272.3 737.2 169.9 M 543.5 375.2 Q 645.2 271.2 749.1 170.0 M 555.2 374.2 Q 657.4 273.9 759.9 170.0 M 565.9 374.6 Q 668.0 273.0 770.5 170.2 M 576.4 374.4 Q 679.8 271.6 781.1 169.6 M 588.1 374.4 Q 690.5 272.8 793.8 169.5 M 598.0 374.7 Q 702.0 272.7 804.7 169.1 M 610.9 374.3 Q 712.7 271.4 815.3 170.1" stroke="#eebefa" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-1)" stroke-linecap="round"/>
+<path d="M 373.6 171.2 Q 498.5 169.0 620.0 169.6 M 618.3 168.9 Q 617.4 272.7 618.3 376.1 M 620.4 374.2 Q 500.2 376.6 374.0 375.6 M 373.9 374.8 Q 377.1 273.3 374.9 168.0" stroke="#862e9c" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 374.4 170.5 Q 498.5 169.9 619.0 170.5 M 618.9 169.4 Q 618.2 272.0 619.1 374.8 M 619.8 375.3 Q 496.2 375.6 373.8 374.2 M 375.4 375.4 Q 374.3 273.6 373.9 170.3" stroke="#862e9c" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="497" y="212" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="23" font-weight="800" fill="#862e9c" text-anchor="middle">2. Webhook</text>
+<text x="497" y="258" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">recognizes HAMi</text>
+<text x="497" y="282.3" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">resources and sets</text>
+<text x="497" y="306.6" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">schedulerName</text>
+<path d="M 625.4 271.7 Q 649.7 269.9 675.1 271.5" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 675.6 270.3 Q 671.5 274.0 661.6 279.3" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 674.3 271.4 Q 667.4 268.6 662.8 263.5" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 480.1 375.3 Q 582.9 273.0 685.7 170.4 M 490.9 375.9 Q 593.5 272.9 696.6 170.9 M 501.8 375.6 Q 605.5 272.6 707.0 169.0 M 512.4 375.0 Q 616.1 271.9 717.8 169.3 M 523.1 374.3 Q 627.9 273.0 729.6 170.9 M 535.2 374.3 Q 637.4 272.0 740.6 171.0 M 545.1 375.1 Q 648.8 273.5 751.7 169.4 M 556.4 375.4 Q 660.0 271.0 761.0 170.3 M 567.5 374.5 Q 669.5 272.7 773.1 169.5 M 579.0 374.5 Q 682.3 271.9 784.4 170.2 M 590.9 375.5 Q 692.0 273.9 795.3 169.4 M 601.6 375.7 Q 704.3 271.2 805.8 169.1 M 612.9 375.8 Q 714.4 271.9 816.1 170.3 M 623.8 374.9 Q 724.2 273.2 828.5 169.8 M 633.1 375.6 Q 735.5 273.3 838.5 170.7 M 644.2 375.3 Q 746.8 273.6 849.3 169.4 M 655.4 374.6 Q 759.0 272.6 861.7 169.0 M 667.3 375.6 Q 769.9 274.0 872.9 170.6 M 677.3 375.6 Q 779.8 273.3 883.1 170.2 M 688.0 374.5 Q 792.9 273.0 893.5 170.7 M 699.5 374.1 Q 802.3 271.3 904.6 170.9 M 710.8 375.8 Q 812.5 274.0 916.4 169.8 M 721.5 374.5 Q 824.1 273.5 927.3 170.4 M 732.5 376.0 Q 834.3 271.3 937.2 169.4 M 744.6 374.5 Q 846.0 273.6 948.7 169.5 M 756.0 375.5 Q 856.7 272.7 961.0 169.9 M 765.5 374.9 Q 867.1 273.9 970.9 169.6 M 776.3 375.7 Q 879.5 271.3 982.5 169.1 M 788.1 374.1 Q 889.8 273.1 992.3 169.4 M 799.0 375.8 Q 901.6 272.5 1004.0 169.1 M 810.5 374.6 Q 911.3 271.0 1015.1 169.2 M 820.5 375.8 Q 924.5 272.8 1026.9 170.4 M 831.4 375.5 Q 934.7 272.0 1037.2 170.9 M 842.3 374.9 Q 945.3 271.6 1048.2 171.0 M 854.2 374.8 Q 957.2 273.9 1058.3 170.3 M 864.9 375.6 Q 966.8 272.5 1069.9 170.8 M 876.5 374.0 Q 978.7 273.9 1080.4 170.0 M 887.9 374.7 Q 988.9 273.3 1091.5 170.2 M 898.8 375.5 Q 1000.0 273.6 1103.8 170.9 M 908.2 374.4 Q 1010.9 272.3 1114.8 170.4 M 919.5 375.1 Q 1023.1 273.5 1125.5 170.1" stroke="#ffd8a8" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-2)" stroke-linecap="round"/>
+<path d="M 686.7 169.0 Q 807.8 168.2 931.1 169.7 M 929.3 168.4 Q 929.1 271.5 929.4 374.4 M 930.8 376.6 Q 808.0 375.2 685.0 375.8 M 683.1 375.8 Q 685.8 272.2 683.2 169.9" stroke="#d9480f" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 684.7 168.9 Q 807.1 171.1 929.3 169.4 M 930.7 171.1 Q 929.3 272.7 929.6 375.1 M 931.0 374.0 Q 806.8 375.6 684.5 375.7 M 685.4 375.0 Q 685.7 273.5 683.9 169.5" stroke="#d9480f" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="807" y="212" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="23" font-weight="800" fill="#d9480f" text-anchor="middle">3. Scheduler extender</text>
+<text x="807" y="258" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">Filter: can it fit?</text>
+<text x="807" y="282.3" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">Score: which GPU?</text>
+<text x="807" y="306.6" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">Bind: write UUID</text>
+<path d="M 936.3 273.0 Q 963.3 269.3 986.2 272.8" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 983.8 270.7 Q 980.6 277.3 974.9 281.2" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 984.1 273.3 Q 980.8 268.0 972.4 262.9" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 789.6 375.5 Q 892.7 272.0 995.4 169.2 M 801.2 375.2 Q 903.5 271.4 1005.5 170.5 M 811.4 374.6 Q 915.5 271.4 1017.3 169.5 M 822.0 374.7 Q 926.0 272.0 1027.0 170.7 M 833.8 374.6 Q 937.8 272.8 1038.5 169.5 M 845.3 375.8 Q 947.0 271.9 1049.8 169.0 M 856.2 374.9 Q 959.3 271.0 1060.6 170.0 M 866.8 374.6 Q 970.0 273.5 1073.0 169.4 M 877.8 374.1 Q 980.6 271.3 1083.2 169.8 M 889.0 374.3 Q 992.0 271.4 1093.9 169.0 M 899.1 375.0 Q 1003.1 274.0 1105.7 171.0 M 911.4 375.2 Q 1013.1 273.0 1116.0 169.9 M 922.4 374.3 Q 1023.9 273.3 1128.0 170.7 M 932.9 375.2 Q 1035.8 272.0 1138.4 170.2 M 943.0 375.5 Q 1046.7 273.4 1148.4 169.2 M 954.9 375.6 Q 1056.7 274.0 1159.8 170.1 M 965.3 375.6 Q 1067.8 273.8 1170.7 169.7 M 977.8 374.9 Q 1079.9 272.2 1181.4 169.4 M 988.2 374.4 Q 1091.2 273.1 1193.9 170.4 M 998.4 376.0 Q 1102.0 271.1 1203.4 170.2 M 1009.8 374.5 Q 1113.6 273.4 1215.4 169.7 M 1020.9 375.7 Q 1123.7 273.5 1226.1 169.4 M 1032.0 375.1 Q 1133.4 273.7 1236.6 170.8 M 1042.0 375.8 Q 1145.0 273.1 1248.3 169.8 M 1054.0 375.0 Q 1157.2 273.8 1259.0 170.6 M 1064.1 375.2 Q 1167.6 271.8 1270.6 170.1 M 1075.2 374.3 Q 1180.0 273.4 1280.5 170.2 M 1086.6 375.3 Q 1188.8 271.5 1292.0 169.6 M 1097.8 375.8 Q 1201.0 271.1 1302.1 170.5 M 1109.4 374.5 Q 1212.9 272.2 1313.0 169.3 M 1119.9 374.6 Q 1223.1 272.9 1324.5 169.5 M 1131.8 374.6 Q 1232.8 272.5 1335.6 169.8 M 1141.3 375.9 Q 1244.0 271.6 1347.2 170.8 M 1153.2 375.3 Q 1255.1 273.5 1358.4 170.0 M 1164.7 374.4 Q 1267.4 272.9 1369.5 171.0 M 1175.1 374.2 Q 1277.9 271.7 1379.2 170.1 M 1186.3 375.9 Q 1289.5 273.2 1392.0 169.5 M 1197.2 374.1 Q 1299.9 272.1 1401.6 170.1 M 1208.8 375.5 Q 1311.7 272.7 1412.1 170.4 M 1218.4 374.6 Q 1322.7 271.4 1424.9 170.8 M 1230.1 375.2 Q 1332.1 271.1 1434.2 170.8" stroke="#b2f2bb" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-3)" stroke-linecap="round"/>
+<path d="M 994.5 169.1 Q 1117.1 167.4 1239.3 169.5 M 1238.1 170.8 Q 1240.4 274.5 1241.3 375.5 M 1240.7 373.7 Q 1119.9 374.1 993.7 374.2 M 996.4 377.0 Q 997.9 274.5 996.6 168.8" stroke="#087f5b" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 995.5 169.7 Q 1118.7 171.8 1239.6 170.9 M 1240.3 169.4 Q 1241.7 271.8 1240.6 375.8 M 1239.2 376.2 Q 1117.0 373.8 994.1 375.4 M 994.2 375.4 Q 994.0 272.4 995.9 170.2" stroke="#087f5b" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="1117" y="212" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="23" font-weight="800" fill="#087f5b" text-anchor="middle">4. Pod annotation</text>
+<text x="1117" y="258" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">GPU UUID</text>
+<text x="1117" y="282.3" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">8000 MiB</text>
+<text x="1117" y="306.6" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">10% compute</text>
+<path d="M 1117.9 384.9 Q 1120.1 439.7 1116.8 491.1" stroke="#087f5b" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 1119.3 490.1 Q 1116.5 482.2 1110.1 478.3" stroke="#087f5b" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 1116.4 490.2 Q 1120.7 485.9 1125.5 477.9" stroke="#087f5b" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 789.6 716.0 Q 892.2 612.3 995.8 510.7 M 800.4 715.8 Q 902.8 611.6 1005.3 510.7 M 811.9 714.9 Q 915.4 613.6 1016.1 509.8 M 823.0 714.8 Q 924.0 611.4 1027.6 509.4 M 833.4 714.7 Q 937.9 612.1 1039.8 510.6 M 845.1 714.2 Q 946.8 613.2 1049.1 510.5 M 856.8 714.9 Q 957.1 612.4 1061.3 510.4 M 866.9 714.6 Q 970.1 611.5 1072.2 510.7 M 877.2 715.2 Q 981.9 612.0 1084.0 509.0 M 889.9 715.8 Q 992.9 613.1 1093.1 510.2 M 899.7 714.1 Q 1002.4 612.4 1105.3 510.8 M 910.3 714.2 Q 1012.3 612.1 1116.0 509.4 M 921.1 714.7 Q 1023.6 612.9 1126.6 510.2 M 933.0 714.1 Q 1034.4 613.5 1137.3 510.9 M 943.3 715.6 Q 1045.6 611.0 1149.0 509.8 M 955.2 714.7 Q 1057.6 611.8 1159.9 510.9 M 966.3 715.1 Q 1068.9 613.9 1171.3 510.2 M 977.2 715.7 Q 1080.2 611.3 1181.8 510.5 M 988.9 714.9 Q 1089.7 613.3 1192.9 510.6 M 998.0 715.8 Q 1100.2 612.5 1203.2 509.7 M 1010.5 714.9 Q 1113.5 612.7 1214.6 510.4 M 1022.0 714.6 Q 1122.8 613.4 1225.1 509.7 M 1031.8 714.8 Q 1133.0 612.7 1237.1 510.8 M 1043.4 714.7 Q 1146.0 613.9 1247.9 509.3 M 1054.0 714.4 Q 1157.2 613.9 1259.4 509.8 M 1065.0 714.9 Q 1166.5 612.1 1269.8 509.8 M 1076.9 715.7 Q 1178.2 611.7 1281.6 510.9 M 1087.6 714.3 Q 1189.1 613.1 1291.9 509.5 M 1098.3 714.9 Q 1200.0 612.3 1302.7 509.4 M 1108.5 714.9 Q 1212.3 613.9 1314.4 509.4 M 1119.6 714.1 Q 1221.8 612.0 1325.5 510.1 M 1131.6 714.6 Q 1232.7 614.0 1336.7 509.8 M 1142.1 714.1 Q 1244.1 611.2 1346.4 509.3 M 1153.7 715.5 Q 1255.4 611.9 1357.2 509.4 M 1164.1 714.1 Q 1266.1 612.6 1368.6 509.8 M 1174.2 714.1 Q 1276.3 611.7 1379.0 509.1 M 1185.5 715.6 Q 1288.0 612.6 1391.4 509.8 M 1196.4 714.0 Q 1299.4 612.0 1402.1 510.3 M 1207.8 715.7 Q 1310.5 611.9 1413.1 509.2 M 1219.1 715.0 Q 1322.8 612.6 1423.2 510.7 M 1229.5 715.0 Q 1333.2 611.3 1436.0 509.3" stroke="#b2f2bb" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-4)" stroke-linecap="round"/>
+<path d="M 993.1 509.4 Q 1115.9 511.1 1240.1 509.4 M 1240.6 508.3 Q 1239.7 613.3 1241.3 714.1 M 1240.6 715.7 Q 1119.8 716.1 996.1 715.7 M 995.2 714.4 Q 996.7 614.6 994.6 509.0" stroke="#087f5b" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 995.3 509.7 Q 1117.4 510.6 1240.5 510.9 M 1239.5 510.9 Q 1240.2 611.0 1240.5 716.2 M 1239.8 714.2 Q 1118.6 715.6 994.6 715.6 M 993.9 714.2 Q 995.3 613.6 995.1 510.5" stroke="#087f5b" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="1117" y="552" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="23" font-weight="800" fill="#087f5b" text-anchor="middle">5. Device plugin</text>
+<text x="1117" y="598" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">/dev/nvidia*</text>
+<text x="1117" y="622.3" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">libvgpu.so</text>
+<text x="1117" y="646.6" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">/etc/ld.so.preload</text>
+<path d="M 984.7 612.8 Q 959.4 609.3 935.2 611.6" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 935.6 611.6 Q 941.3 608.8 950.5 603.2" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 935.6 612.5 Q 942.4 617.3 947.6 618.1" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 479.6 714.2 Q 583.8 612.6 684.4 510.8 M 491.9 715.9 Q 592.0 611.7 696.5 509.9 M 501.8 715.2 Q 604.3 612.0 707.3 510.7 M 513.0 714.1 Q 614.3 613.1 717.9 509.5 M 524.1 715.8 Q 627.2 613.4 729.6 509.3 M 534.7 714.7 Q 636.9 613.0 740.7 510.0 M 546.2 715.5 Q 648.9 613.4 752.0 509.6 M 557.4 714.9 Q 660.1 613.3 761.1 509.9 M 568.8 715.1 Q 669.0 613.7 773.4 510.3 M 578.2 715.0 Q 680.3 613.2 784.8 510.2 M 590.1 716.0 Q 693.1 612.2 796.0 509.7 M 600.6 715.7 Q 703.6 611.8 805.5 510.5 M 611.1 714.2 Q 716.0 613.4 816.3 509.1 M 623.3 714.6 Q 724.6 613.0 829.0 510.9 M 633.5 714.4 Q 735.2 614.0 838.5 509.6 M 645.5 714.4 Q 748.3 612.2 850.4 509.3 M 655.1 714.4 Q 758.9 612.7 861.4 509.7 M 666.3 714.4 Q 769.2 613.0 872.3 510.0 M 677.7 714.3 Q 779.0 611.8 882.4 509.5 M 689.3 715.1 Q 791.1 613.2 894.9 510.9 M 700.2 714.9 Q 803.6 613.3 905.7 509.3 M 711.2 714.4 Q 814.0 612.1 915.6 510.3 M 722.6 714.1 Q 823.9 612.5 926.6 509.9 M 733.3 715.4 Q 836.0 613.2 938.1 509.9 M 744.0 715.4 Q 847.7 613.5 948.2 510.1 M 754.8 714.8 Q 857.1 611.4 959.9 510.1 M 766.2 714.1 Q 868.0 611.3 971.4 510.1 M 777.9 715.1 Q 879.3 612.3 982.8 511.0 M 787.8 715.1 Q 891.6 612.6 993.3 509.5 M 799.6 715.7 Q 901.3 613.2 1004.1 510.3 M 809.4 715.6 Q 912.4 611.6 1015.9 510.8 M 822.0 714.9 Q 922.9 612.9 1025.4 510.0 M 832.6 714.4 Q 933.5 611.2 1036.2 510.1 M 843.1 714.7 Q 944.9 613.4 1048.2 509.3 M 853.6 715.4 Q 957.7 613.9 1059.3 510.2 M 865.1 714.5 Q 966.0 611.7 1070.1 510.5 M 876.1 715.7 Q 979.6 612.0 1080.8 510.9 M 886.4 715.7 Q 989.4 611.8 1091.8 509.4 M 898.8 715.2 Q 1000.6 612.8 1102.8 509.2 M 908.7 714.4 Q 1012.5 612.7 1114.5 509.9 M 920.7 714.2 Q 1022.8 612.4 1125.2 510.0" stroke="#a5d8ff" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-5)" stroke-linecap="round"/>
+<path d="M 683.8 510.5 Q 806.6 512.9 930.2 509.2 M 928.5 509.6 Q 931.6 615.2 928.2 716.9 M 932.0 713.3 Q 805.0 715.7 685.4 715.7 M 684.0 713.8 Q 685.7 610.4 685.4 511.0" stroke="#1971c2" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 685.9 510.1 Q 807.5 509.4 930.3 510.0 M 930.9 510.7 Q 929.3 611.0 929.9 715.1 M 931.1 714.8 Q 808.6 713.2 685.8 714.5 M 684.0 716.0 Q 685.7 613.1 685.8 510.0" stroke="#1971c2" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="807" y="552" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="23" font-weight="800" fill="#1971c2" text-anchor="middle">6. Workload container</text>
+<text x="807" y="598" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">normal PyTorch or</text>
+<text x="807" y="622.3" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">CUDA application</text>
+<text x="807" y="646.6" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">no code change</text>
+<path d="M 674.9 613.6 Q 650.3 611.5 628.8 611.0" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 627.9 613.1 Q 634.6 607.6 639.4 605.2" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 625.8 611.8 Q 633.1 616.0 639.5 620.5" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 169.3 714.1 Q 271.2 611.4 374.6 509.2 M 180.3 714.2 Q 284.8 611.3 385.6 510.1 M 192.6 715.4 Q 295.5 613.2 397.4 510.5 M 202.9 714.5 Q 306.8 612.4 407.4 510.4 M 214.7 714.1 Q 316.9 612.5 419.7 510.9 M 224.8 714.7 Q 327.8 613.8 429.4 510.6 M 236.1 714.2 Q 339.2 613.0 441.2 510.1 M 247.8 715.9 Q 349.5 611.1 451.8 509.2 M 257.8 715.7 Q 361.8 612.4 463.0 510.6 M 269.8 715.1 Q 372.5 613.0 474.2 509.0 M 280.4 714.6 Q 383.5 612.1 485.1 509.8 M 291.0 714.1 Q 394.9 611.7 495.9 509.4 M 301.0 714.0 Q 403.6 612.3 506.4 510.9 M 313.9 714.3 Q 414.1 612.5 519.0 509.7 M 323.3 714.1 Q 426.1 611.2 528.7 510.1 M 335.5 715.4 Q 438.0 613.9 540.7 510.6 M 345.7 714.9 Q 449.1 613.3 550.9 510.3 M 356.4 714.9 Q 459.5 612.2 562.8 509.6 M 367.6 714.5 Q 471.8 611.2 573.6 509.6 M 380.0 715.0 Q 480.2 612.8 585.0 510.0 M 390.7 714.9 Q 491.0 613.7 594.8 511.0 M 401.7 714.5 Q 502.9 611.9 606.5 510.7 M 412.9 716.0 Q 514.0 613.2 616.3 510.3 M 423.0 715.6 Q 526.4 613.9 628.4 509.5 M 434.4 714.5 Q 535.4 613.5 639.9 509.4 M 444.6 715.7 Q 547.0 613.4 650.9 509.6 M 456.5 714.8 Q 559.7 613.2 660.0 510.6 M 466.0 715.8 Q 569.0 613.3 672.7 510.9 M 478.0 714.3 Q 579.1 612.1 683.9 510.8 M 489.7 714.1 Q 591.9 611.5 694.6 509.8 M 499.0 714.3 Q 603.2 612.0 704.4 509.7 M 511.3 714.8 Q 614.9 613.7 716.6 509.5 M 521.7 714.1 Q 624.4 613.5 726.7 509.7 M 533.6 715.1 Q 634.9 613.6 738.5 509.5 M 543.8 716.0 Q 647.7 613.2 748.2 510.5 M 555.2 715.5 Q 657.3 611.5 759.5 509.5 M 566.7 714.9 Q 668.9 612.6 771.2 509.1 M 576.1 715.7 Q 678.0 611.3 781.2 510.8 M 587.3 715.0 Q 689.2 612.8 792.1 510.7 M 599.0 715.0 Q 700.0 611.6 803.2 510.1 M 610.7 714.6 Q 712.2 612.0 815.3 510.0" stroke="#ffc9c9" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-6)" stroke-linecap="round"/>
+<path d="M 374.9 511.7 Q 495.7 512.4 618.1 510.2 M 618.8 511.0 Q 619.9 612.6 622.0 714.2 M 620.8 716.8 Q 498.3 716.8 376.8 716.3 M 373.5 715.7 Q 372.5 615.5 373.9 511.0" stroke="#c92a2a" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 375.5 509.1 Q 496.1 511.3 621.1 510.2 M 619.1 510.2 Q 618.9 613.1 619.6 715.7 M 621.1 716.0 Q 498.0 716.5 374.4 714.9 M 374.4 715.5 Q 373.9 614.0 375.8 509.2" stroke="#c92a2a" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="497" y="552" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="23" font-weight="800" fill="#c92a2a" text-anchor="middle">7. HAMi-Core</text>
+<text x="497" y="598" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">tracks this container</text>
+<text x="497" y="622.3" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">returns OOM past</text>
+<text x="497" y="646.6" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">its memory grant</text>
+<path d="M 365.9 613.0 Q 338.6 609.8 317.5 613.7" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 317.7 613.2 Q 322.3 606.5 328.7 604.5" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 315.2 612.2 Q 323.3 617.0 328.7 619.4" stroke="#172033" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M -140.0 714.0 Q -37.2 611.9 64.1 509.5 M -128.7 714.2 Q -26.7 611.3 75.2 509.0 M -117.9 714.4 Q -16.5 613.3 87.4 509.3 M -107.8 715.3 Q -4.9 611.6 97.5 510.0 M -95.6 714.8 Q 7.8 611.8 109.1 510.8 M -85.5 714.4 Q 17.0 611.3 120.5 509.6 M -73.3 715.7 Q 29.9 611.1 131.7 510.8 M -62.5 715.5 Q 38.3 611.9 142.3 509.7 M -52.8 715.3 Q 49.7 613.3 152.8 509.4 M -41.6 714.7 Q 60.6 611.2 163.9 510.6 M -30.0 715.5 Q 73.2 611.8 175.2 510.0 M -18.3 715.9 Q 82.9 611.3 185.5 509.8 M -8.2 714.5 Q 94.1 612.7 197.3 509.7 M 2.5 715.2 Q 104.2 612.2 208.1 510.7 M 13.1 715.2 Q 115.7 612.5 218.6 509.6 M 26.0 715.0 Q 127.0 611.4 229.4 510.1 M 37.0 715.8 Q 137.7 611.6 241.6 510.3 M 46.2 714.9 Q 148.8 613.9 251.5 509.7 M 57.2 714.3 Q 161.9 612.2 264.0 510.4 M 68.6 715.0 Q 172.5 613.9 274.5 510.3 M 80.9 714.4 Q 181.7 611.3 284.1 509.6 M 90.4 714.0 Q 193.8 613.3 296.7 510.8 M 102.1 715.2 Q 204.9 611.9 307.5 509.4 M 112.1 714.5 Q 215.1 612.8 318.9 509.6 M 125.0 714.8 Q 225.3 611.4 328.9 509.0 M 135.3 715.1 Q 236.1 612.7 339.8 510.1 M 145.4 714.5 Q 248.9 612.0 351.1 510.5 M 157.5 715.6 Q 258.3 612.2 361.0 509.4 M 167.5 715.1 Q 270.2 612.0 372.7 510.6 M 179.8 714.7 Q 280.4 611.4 383.2 509.6 M 191.0 714.6 Q 291.6 613.7 395.8 510.1 M 200.2 715.1 Q 303.1 614.0 405.5 510.7 M 211.4 714.4 Q 314.6 613.4 417.5 509.2 M 222.1 715.4 Q 326.9 611.7 428.4 510.9 M 234.6 714.7 Q 335.4 611.9 438.8 509.7 M 245.2 714.9 Q 348.6 611.6 451.0 509.7 M 256.9 714.9 Q 358.7 613.0 461.7 510.1 M 267.1 714.3 Q 368.1 611.9 471.0 510.0 M 277.9 715.6 Q 380.0 611.2 482.9 509.8 M 288.5 715.1 Q 391.8 611.4 494.6 509.9 M 299.9 715.9 Q 403.5 611.4 504.9 509.5" stroke="#e9ecef" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-7)" stroke-linecap="round"/>
+<path d="M 66.5 510.2 Q 185.0 507.5 309.9 511.5 M 311.9 509.2 Q 312.7 610.2 310.7 713.7 M 311.0 715.6 Q 186.1 713.0 65.0 715.7 M 66.2 715.1 Q 64.8 611.5 64.3 509.1" stroke="#495057" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 64.7 509.0 Q 187.0 510.9 308.9 509.7 M 309.3 509.7 Q 309.7 613.1 310.5 714.5 M 310.8 714.0 Q 188.7 715.8 65.4 714.7 M 65.1 714.4 Q 64.2 611.6 65.6 509.4" stroke="#495057" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="187" y="552" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="23" font-weight="800" fill="#495057" text-anchor="middle">8. Physical GPU</text>
+<text x="187" y="598" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">accepted CUDA work</text>
+<text x="187" y="622.3" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">runs on the real</text>
+<text x="187" y="646.6" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">RTX PRO 6000</text>
+<path d="M 1095.6 367.2 Q 1188.5 271.9 1284.6 177.9 M 1106.5 368.4 Q 1202.2 273.5 1296.4 179.0 M 1116.1 367.8 Q 1211.5 272.6 1307.9 177.3 M 1127.8 368.0 Q 1223.8 273.6 1317.5 177.7 M 1139.4 367.8 Q 1233.2 273.6 1329.6 178.5 M 1150.0 367.6 Q 1246.2 272.3 1339.4 178.3 M 1161.1 367.3 Q 1254.7 274.1 1351.0 177.8 M 1171.4 368.3 Q 1268.0 273.7 1361.2 177.8 M 1183.8 367.0 Q 1277.3 274.0 1373.1 178.2 M 1194.6 368.9 Q 1288.2 273.0 1384.6 179.0 M 1204.1 368.2 Q 1299.8 272.2 1394.6 177.7 M 1215.2 368.0 Q 1311.5 272.8 1405.7 177.8 M 1226.2 367.4 Q 1320.7 274.0 1417.8 178.7 M 1239.0 369.0 Q 1331.9 273.4 1428.6 178.0 M 1248.2 367.6 Q 1344.8 272.2 1439.1 178.5 M 1260.4 367.5 Q 1354.4 271.6 1449.5 177.8 M 1271.0 367.2 Q 1366.9 272.6 1460.7 177.2 M 1282.7 369.0 Q 1376.6 272.2 1472.3 178.4 M 1293.8 368.2 Q 1388.0 272.0 1483.7 177.5 M 1304.4 367.1 Q 1400.0 272.7 1493.5 178.6 M 1315.2 368.3 Q 1409.6 272.7 1505.0 178.0 M 1325.8 368.5 Q 1420.6 273.6 1515.9 177.6 M 1336.6 368.1 Q 1433.1 273.5 1526.7 177.4 M 1348.2 368.4 Q 1443.0 274.4 1537.7 178.7 M 1358.1 368.7 Q 1454.4 272.9 1548.3 178.1 M 1370.8 367.9 Q 1465.2 274.1 1560.9 177.3 M 1381.1 367.8 Q 1476.6 272.4 1571.9 178.6 M 1392.1 368.3 Q 1488.1 273.4 1582.6 177.2 M 1402.2 367.8 Q 1496.6 273.8 1593.5 178.3 M 1414.4 367.7 Q 1507.8 274.0 1603.6 178.5 M 1425.7 368.3 Q 1518.8 273.5 1615.8 177.7 M 1436.6 367.4 Q 1532.5 273.9 1625.7 177.2 M 1446.4 367.7 Q 1542.0 272.1 1636.2 177.2 M 1457.5 367.7 Q 1552.3 272.2 1648.5 178.5 M 1469.4 367.4 Q 1563.7 272.6 1659.5 177.1 M 1480.6 367.3 Q 1574.0 272.7 1670.9 177.2 M 1490.2 367.4 Q 1587.4 273.3 1681.9 177.5 M 1502.2 367.2 Q 1597.1 274.0 1691.1 177.7 M 1512.8 367.8 Q 1608.5 273.2 1703.4 178.2 M 1523.1 367.7 Q 1618.4 272.9 1714.5 178.7 M 1534.8 368.6 Q 1628.7 272.6 1725.3 178.7" stroke="#ffd8a8" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-8)" stroke-linecap="round"/>
+<path d="M 1285.0 178.9 Q 1414.7 177.4 1538.5 176.9 M 1542.0 176.6 Q 1541.6 270.3 1538.1 368.7 M 1540.4 369.1 Q 1411.9 365.2 1283.8 367.3 M 1286.5 366.4 Q 1282.3 273.9 1286.7 179.4" stroke="#d9480f" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round" stroke-dasharray="9 8"/>
+<path d="M 1284.3 178.7 Q 1411.8 177.7 1538.9 177.4 M 1539.0 177.9 Q 1540.0 272.7 1540.6 368.3 M 1540.6 366.9 Q 1413.7 369.0 1284.3 367.4 M 1285.9 367.4 Q 1285.4 273.7 1284.1 178.5" stroke="#d9480f" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round" stroke-dasharray="9 8"/>
+<text x="1412" y="219" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="22" font-weight="800" fill="#d9480f" text-anchor="middle">Scheduling boundary</text>
+<text x="1412" y="260" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">slot available?</text>
+<text x="1412" y="286.1" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">memory available?</text>
+<text x="1412" y="312.2" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">compute available?</text>
+<path d="M 1281.2 275.6 Q 1107.2 274.0 935.2 274.9" stroke="#d9480f" stroke-width="2.6" fill="none" stroke-linecap="round" stroke-dasharray="8 8"/>
+<path d="M 934.4 276.7 Q 938.6 272.3 946.9 268.1" stroke="#d9480f" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 934.9 276.7 Q 941.6 280.9 947.8 282.7" stroke="#d9480f" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 1095.8 710.4 Q 1189.5 614.6 1284.9 519.1 M 1106.9 710.3 Q 1202.4 615.9 1296.1 519.8 M 1116.2 709.2 Q 1213.0 615.0 1306.1 519.4 M 1128.8 709.1 Q 1224.4 613.7 1317.3 519.3 M 1138.5 710.8 Q 1235.1 616.5 1329.1 520.1 M 1149.7 710.7 Q 1244.9 613.5 1340.9 519.5 M 1160.5 710.4 Q 1256.6 615.8 1350.8 520.0 M 1171.1 709.7 Q 1267.3 615.8 1361.2 520.5 M 1183.1 710.3 Q 1278.0 614.0 1372.3 520.9 M 1194.5 709.0 Q 1290.4 613.6 1384.4 519.7 M 1205.1 710.7 Q 1300.2 615.8 1394.5 520.5 M 1215.6 710.3 Q 1311.8 615.0 1405.2 519.4 M 1227.3 710.7 Q 1322.0 615.6 1417.6 520.1 M 1239.0 709.4 Q 1333.5 614.2 1428.8 520.6 M 1248.3 710.5 Q 1343.9 614.1 1439.5 519.3 M 1260.3 710.6 Q 1355.4 613.7 1449.3 520.4 M 1271.8 710.2 Q 1365.3 616.4 1460.6 519.3 M 1281.1 709.3 Q 1376.4 614.5 1472.9 519.3 M 1292.6 709.3 Q 1386.8 615.1 1482.3 520.7 M 1303.0 710.1 Q 1399.3 616.1 1493.4 519.3 M 1314.4 709.2 Q 1410.7 615.7 1505.2 520.3 M 1326.8 710.3 Q 1421.5 615.7 1516.7 519.2 M 1336.0 709.1 Q 1432.0 614.2 1527.1 519.5 M 1347.1 709.7 Q 1442.7 613.7 1538.9 519.5 M 1358.2 710.7 Q 1452.8 615.3 1549.0 520.6 M 1369.3 710.3 Q 1464.7 615.4 1560.0 520.5 M 1381.7 709.8 Q 1475.5 615.0 1571.0 519.2 M 1391.3 710.6 Q 1486.2 615.7 1581.0 519.0 M 1403.2 709.6 Q 1496.7 616.2 1593.9 520.4 M 1413.4 709.1 Q 1509.7 614.9 1603.4 520.6 M 1425.1 710.7 Q 1520.0 614.5 1615.5 519.3 M 1435.6 709.5 Q 1530.7 615.8 1625.4 521.0 M 1447.7 709.1 Q 1542.2 613.5 1636.1 520.2 M 1458.2 709.4 Q 1553.9 613.8 1647.7 519.2 M 1468.6 709.0 Q 1564.0 615.2 1659.7 519.6 M 1480.9 709.2 Q 1574.7 615.4 1669.8 519.5 M 1491.2 709.3 Q 1585.0 614.6 1681.1 520.7 M 1501.2 710.2 Q 1597.2 615.7 1692.2 520.6 M 1512.2 710.8 Q 1608.2 616.0 1702.3 519.6 M 1523.9 710.6 Q 1620.1 615.7 1713.4 520.8 M 1534.2 710.2 Q 1630.1 616.3 1725.0 520.6" stroke="#ffc9c9" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-9)" stroke-linecap="round"/>
+<path d="M 1285.9 520.5 Q 1414.2 518.8 1539.4 518.3 M 1538.7 520.3 Q 1538.0 613.7 1538.7 709.7 M 1541.6 710.7 Q 1414.6 711.8 1284.7 711.3 M 1284.3 710.0 Q 1283.6 614.0 1284.6 518.0" stroke="#c92a2a" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round" stroke-dasharray="9 8"/>
+<path d="M 1285.9 520.4 Q 1411.1 520.3 1539.7 520.6 M 1539.7 520.7 Q 1541.6 613.8 1540.3 709.5 M 1538.9 709.1 Q 1411.7 708.8 1285.6 709.6 M 1284.5 710.5 Q 1285.6 613.6 1285.5 521.0" stroke="#c92a2a" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round" stroke-dasharray="9 8"/>
+<text x="1412" y="561" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="22" font-weight="800" fill="#c92a2a" text-anchor="middle">Runtime boundary</text>
+<text x="1412" y="602" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">CUDA/NVML paths</text>
+<text x="1412" y="628.1" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">inside the process</text>
+<text x="1412" y="654.2" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">software-enforced</text>
+<path d="M 1282.3 615.7 Q 949.5 613.2 614.7 614.7" stroke="#c92a2a" stroke-width="2.6" fill="none" stroke-linecap="round" stroke-dasharray="8 8"/>
+<path d="M 616.5 615.2 Q 621.1 610.8 628.0 606.2" stroke="#c92a2a" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 614.1 615.8 Q 619.2 617.3 626.7 622.5" stroke="#c92a2a" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<text x="800" y="855" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="23" font-weight="500" fill="#5c677d" text-anchor="middle">The scheduler prevents over-commit at placement; HAMi-Core enforces the chosen grant at runtime.</text>
+</svg>
\ No newline at end of file
diff --git a/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-grafana-dashboard.png b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-grafana-dashboard.png
new file mode 100644
index 000000000..f9bd1a1ba
Binary files /dev/null and b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-grafana-dashboard.png differ
diff --git a/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-isolation-spectrum.png b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-isolation-spectrum.png
new file mode 100644
index 000000000..abb26dffb
Binary files /dev/null and b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-isolation-spectrum.png differ
diff --git a/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-isolation-spectrum.svg b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-isolation-spectrum.svg
new file mode 100644
index 000000000..654c6e98a
--- /dev/null
+++ b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/hami-isolation-spectrum.svg
@@ -0,0 +1,81 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1600" height="790" viewBox="0 0 1600 790">
+<defs><clipPath id="hami-clip-0"><rect x="125" y="280" width="92" height="88" rx="7"/></clipPath><clipPath id="hami-clip-1"><rect x="233" y="280" width="92" height="88" rx="7"/></clipPath><clipPath id="hami-clip-2"><rect x="341" y="280" width="92" height="88" rx="7"/></clipPath><clipPath id="hami-clip-3"><rect x="622" y="272" width="90" height="180" rx="7"/></clipPath><clipPath id="hami-clip-4"><rect x="725" y="272" width="135" height="180" rx="7"/></clipPath><clipPath id="hami-clip-5"><rect x="873" y="272" width="105" height="180" rx="7"/></clipPath><clipPath id="hami-clip-6"><rect x="1147" y="262" width="152" height="105" rx="7"/></clipPath><clipPath id="hami-clip-7"><rect x="1321" y="262" width="152" height="105" rx="7"/></clipPath><clipPath id="hami-clip-8"><rect x="1147" y="387" width="152" height="105" rx="7"/></clipPath><clipPath id="hami-clip-9"><rect x="1321" y="387" width="152" height="105" rx="7"/></clipPath></defs>
+<rect width="1600" height="790" fill="#ffffff"/>
+<text x="800" y="62" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="42" font-weight="800" fill="#172033" text-anchor="middle">Three ways to share one GPU</text>
+<text x="800" y="100" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="22" font-weight="500" fill="#5c677d" text-anchor="middle">same goal, very different isolation boundary</text>
+<text x="280" y="155" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="30" font-weight="800" fill="#d9480f" text-anchor="middle">Time-slicing</text>
+<path d="M 75.0 185.0 Q 278.5 183.9 486.6 186.0 M 484.7 184.0 Q 485.9 377.8 483.4 575.5 M 484.0 575.4 Q 280.3 572.2 73.5 573.4 M 76.0 573.5 Q 73.7 382.7 73.7 185.5" stroke="#172033" stroke-width="3" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 74.9 185.6 Q 279.8 185.3 483.8 185.4 M 485.6 184.9 Q 485.6 378.8 484.8 575.1 M 484.1 575.9 Q 279.9 576.2 75.0 576.1 M 75.8 576.0 Q 74.6 381.2 74.6 185.9" stroke="#172033" stroke-width="1.6500000000000001" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="280" y="222" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#5c677d" text-anchor="middle">scheduler slots only</text>
+<path d="M 37.5 368.3 Q 80.9 324.3 126.0 280.5 M 48.6 368.5 Q 92.6 323.5 135.4 279.3 M 58.8 367.3 Q 102.0 322.7 147.2 279.8 M 70.7 367.5 Q 114.7 322.9 158.4 281.0 M 80.2 367.4 Q 126.1 324.4 169.8 280.3 M 93.0 368.3 Q 137.0 323.2 180.2 279.7 M 102.4 367.8 Q 146.3 325.1 191.1 279.4 M 113.6 367.9 Q 157.3 322.9 202.3 279.3 M 125.6 367.7 Q 169.9 323.2 212.4 279.9 M 136.6 368.3 Q 179.2 324.9 224.4 279.4 M 146.4 368.9 Q 190.6 322.6 234.5 279.2 M 157.4 368.0 Q 203.3 324.3 246.3 280.6 M 169.7 367.2 Q 213.2 325.5 257.1 279.3 M 180.3 367.3 Q 223.3 324.5 267.6 280.0 M 190.9 367.5 Q 235.4 324.2 278.8 279.9 M 202.4 368.7 Q 245.3 324.9 289.6 279.3 M 213.6 368.0 Q 256.5 324.0 300.3 279.2" stroke="#ffd8a8" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-0)" stroke-linecap="round"/>
+<path d="M 124.9 281.9 Q 173.9 280.4 215.3 281.6 M 217.4 280.2 Q 218.5 322.5 216.7 369.4 M 217.5 369.6 Q 168.0 369.2 123.5 366.6 M 125.5 366.0 Q 124.9 325.0 126.6 281.3" stroke="#d9480f" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 124.8 279.0 Q 169.3 279.0 217.9 278.9 M 216.3 281.1 Q 218.1 324.1 217.7 368.9 M 216.5 366.9 Q 169.7 368.3 124.8 368.6 M 126.2 366.9 Q 125.0 322.7 125.6 278.8" stroke="#d9480f" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="171" y="333" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="700" fill="#172033" text-anchor="middle">pod A</text>
+<path d="M 145.7 368.1 Q 188.6 324.5 232.6 280.5 M 156.7 367.5 Q 198.9 324.7 244.4 279.8 M 166.3 367.3 Q 210.7 323.0 255.2 280.8 M 177.8 369.0 Q 220.7 323.7 265.8 280.0 M 189.7 367.3 Q 233.3 323.7 277.7 279.3 M 200.5 367.1 Q 244.5 325.0 287.8 280.1 M 210.6 367.5 Q 255.0 324.4 299.0 280.4 M 221.4 368.0 Q 264.8 323.2 310.3 281.0 M 232.9 367.4 Q 278.3 325.4 320.7 280.2 M 244.7 368.2 Q 287.7 323.7 331.2 279.9 M 255.7 368.6 Q 298.3 323.2 343.5 280.9 M 267.0 367.1 Q 310.7 324.8 353.6 279.3 M 277.6 367.2 Q 320.3 323.6 364.4 279.1 M 287.5 368.4 Q 330.6 323.9 375.3 280.5 M 298.7 368.6 Q 344.2 324.3 386.7 279.6 M 310.4 368.7 Q 354.0 323.4 397.2 280.6 M 321.6 367.1 Q 365.7 323.0 409.4 279.2" stroke="#ffd8a8" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-1)" stroke-linecap="round"/>
+<path d="M 232.5 280.5 Q 276.5 280.4 326.1 279.8 M 325.3 279.6 Q 324.4 321.7 324.0 369.0 M 324.5 368.8 Q 278.9 366.1 234.7 367.7 M 234.5 367.5 Q 232.6 323.9 232.1 279.4" stroke="#d9480f" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 233.9 279.3 Q 278.2 279.3 325.0 280.8 M 324.0 280.8 Q 324.9 322.7 324.2 367.1 M 323.9 368.3 Q 278.4 368.1 232.9 368.1 M 232.5 369.0 Q 232.0 322.9 233.4 280.2" stroke="#d9480f" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="279" y="333" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="700" fill="#172033" text-anchor="middle">pod B</text>
+<path d="M 252.8 367.4 Q 296.5 323.5 340.5 279.1 M 263.2 368.3 Q 309.1 325.3 352.9 279.4 M 275.7 368.4 Q 319.7 322.5 362.3 279.1 M 286.3 369.0 Q 330.2 322.6 373.4 280.8 M 296.4 367.4 Q 340.2 323.4 384.2 279.6 M 308.9 367.0 Q 352.4 322.7 396.5 280.1 M 318.5 367.6 Q 363.5 324.5 407.3 280.8 M 330.1 367.9 Q 372.9 325.4 417.2 279.4 M 340.9 368.0 Q 386.0 323.9 428.9 279.4 M 351.4 367.6 Q 396.4 325.2 440.0 279.6 M 362.0 367.1 Q 405.8 324.0 451.2 279.1 M 373.2 367.0 Q 416.5 322.9 461.8 280.8 M 385.7 368.4 Q 428.6 324.0 472.2 280.2 M 396.9 367.3 Q 440.7 323.5 483.5 279.8 M 406.6 367.6 Q 449.5 322.8 495.7 279.6 M 417.0 368.8 Q 461.2 323.3 505.4 279.1 M 429.0 368.8 Q 472.5 323.6 517.0 279.6" stroke="#ffd8a8" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-2)" stroke-linecap="round"/>
+<path d="M 339.0 280.4 Q 388.4 279.6 433.0 279.7 M 432.3 280.5 Q 435.6 323.7 431.6 370.0 M 434.6 366.5 Q 385.3 367.4 340.0 366.6 M 342.1 367.3 Q 342.8 324.1 340.6 280.5" stroke="#d9480f" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 340.5 279.6 Q 387.7 278.4 432.6 280.1 M 434.0 280.5 Q 433.3 323.6 432.3 367.2 M 432.9 368.8 Q 387.0 367.1 340.0 367.8 M 341.9 366.9 Q 340.0 322.6 340.0 279.4" stroke="#d9480f" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="387" y="333" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="700" fill="#172033" text-anchor="middle">pod C</text>
+<path d="M 149.7 430.0 Q 278.5 430.6 408.3 430.0" stroke="#d9480f" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 408.2 429.4 Q 402.1 433.8 399.1 435.8" stroke="#d9480f" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<path d="M 411.4 429.5 Q 401.9 427.5 398.3 421.3" stroke="#d9480f" stroke-width="2.6" fill="none" stroke-linecap="round"/>
+<text x="280" y="472" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="19" font-weight="500" fill="#172033" text-anchor="middle">take turns on one open card</text>
+<text x="280" y="630" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="20" font-weight="700" fill="#d9480f" text-anchor="middle">no per-pod VRAM cap</text>
+<text x="280" y="659" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="20" font-weight="700" fill="#d9480f" text-anchor="middle">all replicas see the full card</text>
+<text x="795" y="155" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="30" font-weight="800" fill="#5d8f00" text-anchor="middle">HAMi</text>
+<path d="M 588.2 185.8 Q 794.1 186.4 999.5 184.2 M 999.8 184.6 Q 1001.2 378.7 1001.4 575.8 M 1001.3 573.3 Q 792.1 576.7 588.5 574.5 M 590.0 576.7 Q 587.2 382.9 589.0 183.6" stroke="#172033" stroke-width="3" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 590.9 184.1 Q 795.8 185.7 1000.0 185.9 M 1000.0 184.0 Q 998.8 380.4 1000.3 575.4 M 1000.2 575.5 Q 793.9 575.8 591.1 574.3 M 589.1 574.4 Q 590.3 379.7 590.4 184.3" stroke="#172033" stroke-width="1.6500000000000001" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="795" y="222" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#5c677d" text-anchor="middle">user-space CUDA/NVML hooks</text>
+<path d="M 442.2 452.7 Q 532.7 360.6 621.9 271.6 M 453.9 452.1 Q 541.7 362.9 632.9 271.9 M 464.1 452.9 Q 554.7 360.8 643.9 272.8 M 474.7 452.8 Q 565.4 361.2 655.4 271.4 M 486.5 451.2 Q 577.1 362.4 665.0 271.4 M 496.3 451.2 Q 585.8 362.0 677.4 271.7 M 508.7 451.4 Q 596.6 361.2 688.7 273.0 M 519.1 451.9 Q 609.7 362.7 699.9 271.3 M 529.4 452.0 Q 619.7 361.3 709.1 272.6 M 541.5 451.2 Q 632.2 363.3 721.2 271.6 M 551.8 452.4 Q 642.8 360.9 732.2 271.5 M 563.8 452.4 Q 651.9 361.1 742.3 272.9 M 574.1 452.1 Q 665.4 361.9 754.8 271.8 M 585.6 452.0 Q 673.9 363.4 764.6 271.9 M 596.9 452.5 Q 684.9 362.6 776.1 272.3 M 607.6 451.5 Q 697.1 361.8 787.7 272.3 M 618.0 451.9 Q 707.1 360.8 797.2 272.8 M 628.8 452.1 Q 720.0 361.0 808.2 272.0 M 640.7 452.3 Q 728.7 362.8 819.5 271.9 M 651.8 451.1 Q 740.5 361.3 831.7 271.2 M 661.4 451.4 Q 753.4 361.3 841.2 272.0 M 672.9 451.4 Q 764.3 363.1 853.0 271.9 M 683.6 451.7 Q 775.2 362.1 863.3 272.1 M 695.7 451.5 Q 784.4 362.1 875.9 271.9 M 705.2 452.4 Q 794.9 362.0 886.9 272.4" stroke="#d8f5a2" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-3)" stroke-linecap="round"/>
+<path d="M 623.3 272.6 Q 664.3 273.5 712.0 273.1 M 712.0 270.5 Q 714.2 361.2 710.8 453.4 M 712.9 451.3 Q 669.2 451.5 621.7 452.8 M 622.0 451.1 Q 623.4 360.2 623.6 270.4" stroke="#5d8f00" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 622.5 272.0 Q 666.2 270.9 713.0 272.0 M 712.1 272.9 Q 711.7 360.5 713.1 453.0 M 711.2 452.0 Q 667.0 451.9 621.1 453.1 M 622.6 451.9 Q 621.1 363.7 622.7 271.3" stroke="#5d8f00" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="667" y="325" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="17" font-weight="700" fill="#172033" text-anchor="middle">pod A</text>
+<text x="667" y="360" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">8 GB</text>
+<text x="667" y="392" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="17" font-weight="500" fill="#5c677d" text-anchor="middle">10%</text>
+<path d="M 544.6 451.6 Q 636.5 361.0 725.2 272.6 M 555.9 452.3 Q 646.2 361.6 736.2 271.1 M 566.6 451.5 Q 655.8 361.6 747.4 271.2 M 577.4 451.0 Q 668.9 363.2 757.9 271.4 M 588.6 452.4 Q 679.6 360.8 768.2 272.5 M 600.3 451.2 Q 690.4 362.7 780.2 271.5 M 610.6 451.3 Q 702.0 362.9 790.6 272.6 M 622.8 451.7 Q 712.1 362.7 802.2 271.9 M 632.6 452.7 Q 723.5 361.7 812.3 271.4 M 643.1 451.8 Q 735.0 361.5 823.5 272.6 M 655.3 451.3 Q 745.7 362.1 834.8 272.6 M 666.5 451.3 Q 754.6 363.5 846.6 272.2 M 677.3 452.0 Q 767.0 361.3 856.4 272.6 M 687.6 452.9 Q 776.8 360.8 868.8 272.4 M 698.4 452.3 Q 789.5 362.9 878.2 271.9 M 709.1 451.5 Q 800.9 361.8 890.7 272.4 M 720.3 452.1 Q 809.9 360.8 900.4 273.0 M 731.6 452.6 Q 822.9 363.3 912.9 271.3 M 742.2 451.6 Q 832.5 362.5 923.9 272.8 M 753.1 452.5 Q 843.1 362.6 934.0 272.1 M 764.4 451.0 Q 855.6 362.9 945.4 272.3 M 775.2 452.5 Q 864.8 361.5 956.4 271.8 M 787.6 451.7 Q 877.6 361.6 967.6 271.1 M 797.1 452.6 Q 888.1 362.7 977.4 271.4 M 809.6 451.7 Q 899.8 361.7 989.2 272.1 M 820.7 451.5 Q 909.4 362.3 999.9 272.0 M 830.3 452.1 Q 920.5 360.8 1010.1 272.4 M 841.5 452.3 Q 931.6 360.9 1022.4 272.3 M 852.6 451.6 Q 943.4 361.8 1033.3 272.8" stroke="#d8f5a2" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-4)" stroke-linecap="round"/>
+<path d="M 724.1 272.3 Q 794.9 273.6 858.2 271.8 M 860.2 274.0 Q 860.7 361.2 858.9 452.9 M 858.7 453.2 Q 791.0 454.6 726.5 451.4 M 724.6 452.1 Q 726.8 361.1 723.6 272.3" stroke="#5d8f00" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round" stroke-dasharray="9 8"/>
+<path d="M 724.6 272.1 Q 792.6 273.7 859.9 272.0 M 859.8 272.8 Q 861.6 360.7 859.8 452.7 M 859.4 452.3 Q 791.3 450.8 725.9 452.3 M 725.0 450.9 Q 726.6 363.8 724.5 271.0" stroke="#5d8f00" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round" stroke-dasharray="9 8"/>
+<text x="792.5" y="325" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="17" font-weight="700" fill="#172033" text-anchor="middle">pod B</text>
+<text x="792.5" y="360" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">20 GB</text>
+<text x="792.5" y="392" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="17" font-weight="500" fill="#5c677d" text-anchor="middle">35%</text>
+<path d="M 693.6 451.9 Q 784.4 361.1 872.6 272.1 M 704.0 452.8 Q 794.9 361.4 883.1 272.1 M 714.3 451.2 Q 806.3 361.6 895.1 272.2 M 726.0 451.4 Q 817.0 362.5 906.5 271.1 M 737.0 452.9 Q 827.8 361.8 916.1 272.4 M 747.3 452.6 Q 837.8 361.4 927.1 272.3 M 758.5 452.6 Q 849.5 362.5 939.7 271.1 M 770.6 451.9 Q 860.9 362.2 949.4 271.3 M 780.2 451.1 Q 871.2 363.0 960.9 271.5 M 792.4 451.9 Q 883.2 362.2 972.3 271.0 M 802.5 452.1 Q 891.7 362.7 982.9 272.8 M 813.0 451.8 Q 904.0 363.3 993.4 272.7 M 824.9 452.9 Q 915.7 362.3 1004.5 272.7 M 836.0 452.3 Q 925.0 361.7 1015.5 271.7 M 846.3 451.7 Q 935.8 362.8 1027.6 272.0 M 857.7 452.4 Q 949.1 361.5 1038.4 272.6 M 869.1 452.4 Q 959.5 362.4 1048.9 272.8 M 880.3 451.6 Q 970.6 362.3 1060.5 271.1 M 891.6 452.4 Q 982.0 362.1 1070.6 271.9 M 901.8 452.6 Q 991.0 361.5 1083.0 272.2 M 912.1 452.9 Q 1002.8 363.4 1092.2 272.0 M 923.3 452.8 Q 1015.0 362.6 1103.6 272.1 M 934.4 451.6 Q 1025.6 362.9 1114.4 271.5 M 945.5 451.5 Q 1035.0 362.6 1125.4 272.8 M 957.3 452.5 Q 1048.0 362.5 1136.7 273.0 M 967.5 452.8 Q 1058.5 362.7 1148.6 271.5" stroke="#d8f5a2" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-5)" stroke-linecap="round"/>
+<path d="M 871.8 272.0 Q 927.0 273.0 977.4 273.5 M 978.2 271.3 Q 978.0 363.5 978.2 453.1 M 977.1 452.1 Q 927.9 452.0 871.6 452.4 M 873.5 452.1 Q 875.1 364.3 871.9 273.1" stroke="#5d8f00" stroke-width="2.4" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 872.7 273.1 Q 926.0 272.3 977.4 272.0 M 978.4 272.4 Q 977.1 363.2 977.7 451.8 M 978.5 452.9 Q 924.3 451.5 872.7 451.4 M 872.0 451.3 Q 871.4 363.6 872.8 272.2" stroke="#5d8f00" stroke-width="1.32" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="925.5" y="325" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="17" font-weight="700" fill="#172033" text-anchor="middle">pod C</text>
+<text x="925.5" y="360" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#172033" text-anchor="middle">12 GB</text>
+<text x="925.5" y="392" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="17" font-weight="500" fill="#5c677d" text-anchor="middle">15%</text>
+<text x="795" y="500" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="19" font-weight="500" fill="#172033" text-anchor="middle">shared silicon, separate accounts</text>
+<text x="795" y="630" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="20" font-weight="700" fill="#5d8f00" text-anchor="middle">arbitrary MiB + 1% core steps</text>
+<text x="795" y="659" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="20" font-weight="700" fill="#5d8f00" text-anchor="middle">best-effort software isolation</text>
+<text x="1310" y="155" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="30" font-weight="800" fill="#1971c2" text-anchor="middle">MIG</text>
+<path d="M 1105.8 186.3 Q 1307.5 184.1 1514.3 184.2 M 1515.4 186.8 Q 1512.4 377.6 1515.3 573.4 M 1516.2 573.1 Q 1309.1 575.2 1105.1 576.3 M 1105.0 573.9 Q 1107.4 381.7 1106.7 183.2" stroke="#172033" stroke-width="3" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 1104.6 185.1 Q 1310.9 186.1 1514.0 184.0 M 1515.6 183.9 Q 1514.8 379.6 1516.0 574.0 M 1515.9 575.0 Q 1309.8 575.4 1104.9 575.3 M 1105.4 574.2 Q 1105.3 381.5 1105.8 184.8" stroke="#172033" stroke-width="1.6500000000000001" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="1310" y="222" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="18" font-weight="500" fill="#5c677d" text-anchor="middle">hardware partitions</text>
+<path d="M 1041.7 367.5 Q 1095.7 313.2 1147.5 262.9 M 1053.7 367.7 Q 1106.6 315.0 1158.5 262.3 M 1064.1 366.7 Q 1117.4 313.7 1168.4 262.4 M 1074.8 367.0 Q 1128.8 313.7 1181.0 261.0 M 1086.0 367.7 Q 1139.3 315.9 1191.6 261.7 M 1097.1 367.2 Q 1148.6 315.1 1201.2 262.5 M 1108.2 366.4 Q 1161.1 315.8 1213.2 261.1 M 1118.4 366.6 Q 1170.2 314.3 1223.6 262.5 M 1130.2 366.0 Q 1181.8 313.6 1235.4 261.3 M 1140.7 367.5 Q 1192.9 315.1 1246.1 262.6 M 1152.8 366.3 Q 1203.2 315.4 1257.3 262.7 M 1163.8 367.5 Q 1215.8 314.4 1267.2 261.7 M 1173.2 366.6 Q 1227.3 313.5 1279.1 262.4 M 1185.3 367.8 Q 1238.7 314.9 1290.5 262.4 M 1195.7 367.2 Q 1248.6 313.1 1301.6 262.4 M 1206.5 366.5 Q 1258.3 314.7 1312.8 262.1 M 1217.6 367.5 Q 1270.6 315.2 1323.1 262.1 M 1228.8 367.5 Q 1282.4 314.3 1334.0 262.6 M 1240.2 367.8 Q 1293.2 314.1 1345.4 262.4 M 1251.7 366.9 Q 1303.4 315.3 1355.1 261.1 M 1261.6 366.3 Q 1315.1 315.6 1366.0 261.5 M 1273.9 367.2 Q 1326.0 315.5 1378.2 261.8 M 1283.2 367.8 Q 1336.8 315.3 1389.4 262.4 M 1294.7 367.6 Q 1346.7 314.6 1400.7 261.6" stroke="#a5d8ff" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-6)" stroke-linecap="round"/>
+<path d="M 1148.8 261.4 Q 1221.2 261.8 1299.1 261.5 M 1299.7 261.3 Q 1298.8 312.6 1299.7 368.3 M 1298.4 367.1 Q 1220.4 364.0 1147.5 366.7 M 1145.7 365.9 Q 1148.2 316.0 1148.5 260.3" stroke="#1971c2" stroke-width="2.8" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 1148.2 261.7 Q 1222.0 263.5 1298.4 261.6 M 1300.0 261.5 Q 1298.8 316.2 1297.9 366.5 M 1299.0 366.3 Q 1224.0 367.3 1145.9 367.2 M 1147.0 367.4 Q 1147.8 314.4 1148.0 261.1" stroke="#1971c2" stroke-width="1.54" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="1223" y="310" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="19" font-weight="700" fill="#172033" text-anchor="middle">1g.24gb</text>
+<text x="1223" y="340" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="16" font-weight="500" fill="#5c677d" text-anchor="middle">own SMs</text>
+<path d="M 1216.7 366.8 Q 1267.3 315.3 1320.8 261.3 M 1227.5 367.7 Q 1278.7 314.3 1332.3 262.2 M 1238.9 366.5 Q 1291.2 313.3 1342.2 261.3 M 1248.7 367.4 Q 1302.5 314.7 1353.6 262.6 M 1260.9 366.1 Q 1313.4 315.1 1364.8 262.2 M 1271.7 368.0 Q 1324.0 315.4 1376.1 262.0 M 1281.4 367.9 Q 1333.6 315.3 1387.3 261.5 M 1293.6 367.5 Q 1346.5 316.0 1397.6 262.9 M 1303.8 366.4 Q 1355.6 314.4 1409.9 261.2 M 1315.2 366.2 Q 1368.6 314.0 1419.8 262.3 M 1325.7 367.8 Q 1379.0 315.7 1430.5 262.4 M 1337.7 366.7 Q 1389.8 313.9 1442.4 262.1 M 1347.2 366.9 Q 1400.9 315.4 1453.9 262.6 M 1359.6 366.1 Q 1410.2 314.6 1464.1 262.1 M 1369.5 367.7 Q 1422.3 314.5 1475.1 261.3 M 1380.7 366.1 Q 1432.7 314.4 1485.4 262.8 M 1392.3 367.9 Q 1443.5 315.1 1497.8 262.2 M 1403.1 366.7 Q 1456.2 313.3 1507.8 262.9 M 1413.8 367.6 Q 1468.0 313.3 1518.5 262.9 M 1424.5 367.0 Q 1478.5 315.3 1530.7 261.1 M 1435.1 367.8 Q 1489.7 314.6 1540.6 261.6 M 1447.6 367.4 Q 1498.4 313.7 1552.5 262.4 M 1458.5 366.1 Q 1511.5 313.8 1562.9 262.0 M 1469.4 367.9 Q 1522.2 315.9 1574.6 261.2" stroke="#a5d8ff" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-7)" stroke-linecap="round"/>
+<path d="M 1321.8 263.8 Q 1395.3 262.9 1473.9 260.7 M 1473.5 261.0 Q 1473.4 312.7 1472.1 365.5 M 1472.8 368.3 Q 1397.0 366.6 1319.0 365.7 M 1322.0 366.2 Q 1322.5 315.6 1320.5 263.5" stroke="#1971c2" stroke-width="2.8" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 1321.0 261.0 Q 1396.7 261.7 1473.3 262.2 M 1472.6 261.3 Q 1474.2 313.2 1472.3 367.5 M 1473.3 366.3 Q 1396.1 366.6 1321.4 367.5 M 1320.0 367.7 Q 1320.6 315.4 1320.5 263.2" stroke="#1971c2" stroke-width="1.54" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="1397" y="310" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="19" font-weight="700" fill="#172033" text-anchor="middle">1g.24gb</text>
+<text x="1397" y="340" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="16" font-weight="500" fill="#5c677d" text-anchor="middle">own SMs</text>
+<path d="M 1042.9 491.6 Q 1095.6 438.8 1146.0 386.4 M 1053.1 492.9 Q 1105.1 440.9 1158.0 386.1 M 1064.2 492.7 Q 1116.4 439.1 1168.4 387.5 M 1075.8 491.1 Q 1126.2 440.8 1179.4 387.2 M 1086.3 491.3 Q 1138.4 439.8 1191.2 386.3 M 1097.5 492.4 Q 1149.9 440.9 1202.8 387.5 M 1108.9 492.4 Q 1159.9 439.9 1213.6 386.7 M 1118.5 491.4 Q 1171.6 440.1 1224.0 386.3 M 1130.1 491.8 Q 1183.2 440.8 1235.1 387.9 M 1141.0 492.3 Q 1193.5 440.8 1245.1 386.3 M 1152.9 492.5 Q 1205.7 440.7 1256.2 387.5 M 1163.6 492.4 Q 1214.8 438.3 1268.0 386.3 M 1174.6 491.2 Q 1227.3 440.6 1278.1 387.1 M 1185.1 491.8 Q 1238.6 440.9 1289.4 387.3 M 1197.0 492.3 Q 1247.2 440.8 1300.2 386.2 M 1207.6 491.8 Q 1260.1 440.5 1311.8 387.6 M 1218.4 491.1 Q 1269.6 438.1 1323.5 386.6 M 1228.0 492.6 Q 1280.6 438.8 1333.3 387.1 M 1239.6 491.2 Q 1291.5 440.5 1344.8 387.8 M 1250.8 491.3 Q 1303.8 438.8 1355.0 387.6 M 1262.6 491.3 Q 1314.3 441.0 1367.6 387.3 M 1273.5 492.0 Q 1326.6 440.3 1378.7 386.5 M 1284.8 491.6 Q 1336.0 439.2 1388.6 387.5 M 1294.4 491.7 Q 1347.5 440.2 1400.7 387.9" stroke="#a5d8ff" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-8)" stroke-linecap="round"/>
+<path d="M 1145.2 386.9 Q 1222.3 385.5 1298.3 385.8 M 1298.5 387.5 Q 1296.9 438.5 1300.9 493.0 M 1299.5 490.5 Q 1225.9 489.1 1145.2 490.5 M 1148.8 492.1 Q 1148.4 441.6 1146.3 385.5" stroke="#1971c2" stroke-width="2.8" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 1147.3 388.0 Q 1223.3 388.1 1300.2 387.3 M 1299.7 387.6 Q 1299.2 437.7 1298.9 491.0 M 1298.7 491.7 Q 1223.7 490.4 1147.1 492.6 M 1147.5 492.5 Q 1147.2 439.6 1146.6 387.7" stroke="#1971c2" stroke-width="1.54" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="1223" y="435" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="19" font-weight="700" fill="#172033" text-anchor="middle">1g.24gb</text>
+<text x="1223" y="465" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="16" font-weight="500" fill="#5c677d" text-anchor="middle">own SMs</text>
+<path d="M 1216.3 492.4 Q 1269.7 440.9 1320.6 387.5 M 1226.9 492.6 Q 1279.7 441.0 1332.5 387.2 M 1237.1 492.9 Q 1290.7 440.7 1342.9 386.7 M 1249.7 491.4 Q 1302.8 440.7 1353.5 386.6 M 1260.1 492.8 Q 1313.0 439.5 1365.3 387.6 M 1270.6 492.8 Q 1323.7 439.5 1375.8 386.5 M 1281.9 492.2 Q 1333.6 440.1 1387.4 387.7 M 1293.2 491.7 Q 1344.2 440.7 1398.0 386.2 M 1304.1 492.6 Q 1356.6 439.4 1409.7 386.8 M 1315.4 492.6 Q 1366.6 438.7 1420.4 387.6 M 1326.0 492.2 Q 1377.5 439.0 1430.5 386.9 M 1337.3 492.5 Q 1389.1 439.3 1441.4 386.8 M 1348.4 491.8 Q 1399.7 440.3 1453.9 386.9 M 1359.1 491.0 Q 1410.8 438.1 1463.3 386.9 M 1369.4 491.5 Q 1421.0 438.7 1474.6 386.6 M 1380.8 491.8 Q 1433.2 439.6 1486.2 386.8 M 1391.3 492.4 Q 1444.7 440.5 1496.3 386.4 M 1402.7 492.4 Q 1454.6 438.4 1508.3 387.0 M 1414.4 492.2 Q 1465.6 439.5 1519.8 386.4 M 1425.8 492.9 Q 1478.8 438.5 1530.6 386.0 M 1435.3 492.3 Q 1487.1 438.4 1540.5 386.1 M 1446.8 491.9 Q 1499.9 440.0 1552.8 387.7 M 1458.3 492.6 Q 1509.1 440.6 1563.4 386.4 M 1469.3 492.2 Q 1522.1 440.8 1574.1 387.5" stroke="#a5d8ff" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#hami-clip-9)" stroke-linecap="round"/>
+<path d="M 1320.2 388.5 Q 1400.0 388.4 1472.8 385.9 M 1471.2 388.0 Q 1475.6 436.8 1471.0 492.0 M 1475.0 492.0 Q 1396.9 494.2 1321.9 491.6 M 1320.8 490.6 Q 1321.8 438.8 1322.7 387.1" stroke="#1971c2" stroke-width="2.8" opacity="1" fill="none" stroke-linecap="round"/>
+<path d="M 1321.4 388.0 Q 1397.6 385.9 1473.3 388.0 M 1472.6 386.1 Q 1472.0 438.6 1472.4 493.1 M 1472.1 493.2 Q 1398.3 490.7 1320.0 492.4 M 1320.1 492.4 Q 1321.3 440.5 1321.0 388.0" stroke="#1971c2" stroke-width="1.54" opacity="0.55" fill="none" stroke-linecap="round"/>
+<text x="1397" y="435" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="19" font-weight="700" fill="#172033" text-anchor="middle">1g.24gb</text>
+<text x="1397" y="465" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="16" font-weight="500" fill="#5c677d" text-anchor="middle">own SMs</text>
+<text x="1310" y="520" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="19" font-weight="500" fill="#172033" text-anchor="middle">walls are built into the GPU</text>
+<text x="1310" y="630" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="20" font-weight="700" fill="#1971c2" text-anchor="middle">fixed profiles on supported GPUs</text>
+<text x="1310" y="659" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="20" font-weight="700" fill="#1971c2" text-anchor="middle">strong memory + compute isolation</text>
+<text x="800" y="750" font-family="Chalkboard SE, Comic Sans MS, sans-serif" font-size="23" font-weight="500" fill="#5c677d" text-anchor="middle">Choose flexibility, simplicity, or the strongest boundary based on the workload, not the buzzword.</text>
+</svg>
\ No newline at end of file
diff --git a/public/img/blog/sharing-gpus-in-kubernetes-with-hami/oom-blast-radius.png b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/oom-blast-radius.png
new file mode 100644
index 000000000..5305587b6
Binary files /dev/null and b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/oom-blast-radius.png differ
diff --git a/public/img/blog/sharing-gpus-in-kubernetes-with-hami/two-pods-one-gpu.png b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/two-pods-one-gpu.png
new file mode 100644
index 000000000..017030b5d
Binary files /dev/null and b/public/img/blog/sharing-gpus-in-kubernetes-with-hami/two-pods-one-gpu.png differ
diff --git a/public/llms.txt b/public/llms.txt
index 0096004a9..ac66ab55f 100644
--- a/public/llms.txt
+++ b/public/llms.txt
@@ -4,7 +4,7 @@
 
 ## About
 
-Kubesimplify is a community-driven publication on cloud-native technologies, with 191 in-depth technical articles by 62 practitioner authors. We cover Kubernetes (kubelet internals, scheduling, networking, operators), container runtimes (containerd, CRI-O, Docker), GitOps (Argo CD, Flux), service meshes, observability, AI/ML infrastructure on Kubernetes, GPU workloads, platform engineering, and the broader CNCF ecosystem.
+Kubesimplify is a community-driven publication on cloud-native technologies, with 192 in-depth technical articles by 62 practitioner authors. We cover Kubernetes (kubelet internals, scheduling, networking, operators), container runtimes (containerd, CRI-O, Docker), GitOps (Argo CD, Flux), service meshes, observability, AI/ML infrastructure on Kubernetes, GPU workloads, platform engineering, and the broader CNCF ecosystem.
 
 Authoritative, practitioner-written, citation-friendly. Articles include code examples, diagrams, and references.
 
@@ -34,8 +34,9 @@ Authoritative, practitioner-written, citation-friendly. Articles include code ex
 - Cloud Native Security: https://blog.kubesimplify.com/hub/security (network policies, Falco, Kyverno, SLSA supply-chain)
 - Linux Fundamentals: https://blog.kubesimplify.com/hub/linux (shell, sysadmin, networking primitives)
 
-## Recent posts (most recent 30 of 191)
+## Recent posts (most recent 30 of 192)
 
+- [How to Share GPUs in Kubernetes at Scale with HAMi (Software vGPU Slicing)](https://blog.kubesimplify.com/sharing-gpus-in-kubernetes-with-hami) (2026-07-21). Share NVIDIA GPUs in Kubernetes with HAMi software vGPU slicing: memory and compute limits, Helm configuration, a verified PyTorch manifest, a real RTX PRO 6000 OOM test, and Prometheus monitoring.
 - [Slicing GPUs in Kubernetes with NVIDIA Multi-Instance GPU (MIG)](https://blog.kubesimplify.com/slicing-gpus-in-kubernetes-with-nvidia-mig) (2026-07-20). GPU sharing in Kubernetes explained: time-slicing vs MPS vs MIG, every nvidia-smi command to enable and disable MIG on one GPU or eight, GPU Operator automation, pitfalls, and DCGM monitoring.
 - [Day 5: Local LLM Inference Engines, Wrappers, and What to Pick](https://blog.kubesimplify.com/day-5-local-llm-inference-engines-wrappers-and-what-to-pick) (2026-07-17). A beginner-friendly guide to local LLM inference, with the same Qwen model tested through Ollama, llama.cpp, Docker Model Runner, vLLM, SGLang, and TensorRT-LLM on NVIDIA DGX Spark.
 - [Bonsai 27B on RTX PRO 6000 vs DGX Spark: what actually works](https://blog.kubesimplify.com/bonsai-27b-rtx-pro-6000-dgx-spark) (2026-07-16). Real Bonsai 27B benchmarks on an RTX PRO 6000 and a DGX Spark, including the supported llama.cpp setup, ternary vs 1-bit results, and speculative decoding.
@@ -65,11 +66,10 @@ Authoritative, practitioner-written, citation-friendly. Articles include code ex
 - [\"SSH Into Your DGX Spark From Anywhere in the World Using Tailscale](https://blog.kubesimplify.com/ssh-into-your-dgx-spark-from-anywhere-in-the-world-using-tailscale) (2026-04-07). Learn how to set up Tailscale on your NVIDIA DGX Spark for secure SSH access from anywhere in the world.
 - [What Claude Code's Leaked Source Actually Teaches Us About Building AI Agents](https://blog.kubesimplify.com/claude-code-leak-what-the-source-actually-teaches) (2026-04-01). 512K lines of TypeScript, verified against actual source. The engineering patterns in Claude Code's leaked codebase that most coverage got wrong.
 - [The Ingress NGINX Migration Just Got Easier: 119 Annotations, 3 Targets, Impact Ratings](https://blog.kubesimplify.com/ing-switch-119-annotations-gateway-api-traefik-impact-ratings) (2026-03-30). \"Ingress NGINX was archived March 24, 2026. ing-switch maps all 119 NGINX annotations with
-- [clawspark: Your Private OpenClaw AI Assistant That Never Phones Home](https://blog.kubesimplify.com/clawspark-your-private-openclaw-ai-assistant-that-never-phones-home) (2026-03-15). Clawspark provides a way to Install openclaw on your device in a secure way with a single command. 
 
 ## Topics covered (auto-derived from tags)
 
-- kubernetes (96 articles): https://blog.kubesimplify.com/tag/kubernetes
+- kubernetes (97 articles): https://blog.kubesimplify.com/tag/kubernetes
 - devops (71 articles): https://blog.kubesimplify.com/tag/devops
 - docker (31 articles): https://blog.kubesimplify.com/tag/docker
 - k8s (27 articles): https://blog.kubesimplify.com/tag/k8s
@@ -80,7 +80,7 @@ Authoritative, practitioner-written, citation-friendly. Articles include code ex
 - llm (11 articles): https://blog.kubesimplify.com/tag/llm
 - cloud-native (11 articles): https://blog.kubesimplify.com/tag/cloud-native
 - security (11 articles): https://blog.kubesimplify.com/tag/security
-- nvidia (9 articles): https://blog.kubesimplify.com/tag/nvidia
+- nvidia (10 articles): https://blog.kubesimplify.com/tag/nvidia
 - go (9 articles): https://blog.kubesimplify.com/tag/go
 - git (9 articles): https://blog.kubesimplify.com/tag/git
 - linux-for-beginners (9 articles): https://blog.kubesimplify.com/tag/linux-for-beginners
@@ -104,9 +104,9 @@ Authoritative, practitioner-written, citation-friendly. Articles include code ex
 - [Anurag Kumar](https://blog.kubesimplify.com/author/anurag-kumar) (8 posts)
 - [sysxplore](https://blog.kubesimplify.com/author/sysxplore) (6 posts)
 - [Arnav Barman](https://blog.kubesimplify.com/author/arnav-barman) (5 posts)
+- [Shubham Katara](https://blog.kubesimplify.com/author/shubham-katara) (4 posts)
 - [Srinivas Karnati](https://blog.kubesimplify.com/author/srinivas-karnati) (4 posts)
 - [Barkatul Mujauddin](https://blog.kubesimplify.com/author/barkatul-mujauddin) (4 posts)
-- [Shubham Katara](https://blog.kubesimplify.com/author/shubham-katara) (3 posts)
 - [Santoshdts](https://blog.kubesimplify.com/author/santoshdts) (3 posts)
 - [Rishit Dagli](https://blog.kubesimplify.com/author/rishit-dagli) (3 posts)
 - [Bishal Das](https://blog.kubesimplify.com/author/bishal-das) (3 posts)
diff --git a/public/rss.xml b/public/rss.xml
index 2e9ce74bb..26b36de1e 100644
--- a/public/rss.xml
+++ b/public/rss.xml
@@ -6,8 +6,16 @@
     <atom:link href="https://blog.kubesimplify.com/rss.xml" rel="self" type="application/rss+xml"/>
     <description>Deep dives on Kubernetes, AI infrastructure, GitOps, and the cloud-native stack, written by practitioners.</description>
     <language>en-us</language>
-    <lastBuildDate>Mon, 20 Jul 2026 10:00:00 GMT</lastBuildDate>
+    <lastBuildDate>Tue, 21 Jul 2026 10:00:00 GMT</lastBuildDate>
     <generator>Kubesimplify static blog</generator>
+    <item>
+      <title>How to Share GPUs in Kubernetes at Scale with HAMi (Software vGPU Slicing)</title>
+      <link>https://blog.kubesimplify.com/sharing-gpus-in-kubernetes-with-hami</link>
+      <guid isPermaLink="true">https://blog.kubesimplify.com/sharing-gpus-in-kubernetes-with-hami</guid>
+      <pubDate>Tue, 21 Jul 2026 10:00:00 GMT</pubDate>
+      <description>Share NVIDIA GPUs in Kubernetes with HAMi software vGPU slicing: memory and compute limits, Helm configuration, a verified PyTorch manifest, a real RTX PRO 6000 OOM test, and Prometheus monitoring.</description>
+      <category>kubernetes</category><category>gpu</category><category>nvidia</category><category>platform-engineering</category>
+    </item>
     <item>
       <title>Slicing GPUs in Kubernetes with NVIDIA Multi-Instance GPU (MIG)</title>
       <link>https://blog.kubesimplify.com/slicing-gpus-in-kubernetes-with-nvidia-mig</link>
diff --git a/scripts/gen-hami-diagrams.mjs b/scripts/gen-hami-diagrams.mjs
new file mode 100644
index 000000000..54634fcc2
--- /dev/null
+++ b/scripts/gen-hami-diagrams.mjs
@@ -0,0 +1,282 @@
+// Excalidraw-style diagrams for the HAMi GPU sharing article.
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+let seed = 73;
+const random = () => {
+  seed = (seed * 16807) % 2147483647;
+  return seed / 2147483647;
+};
+const jitter = (amount) => (random() - 0.5) * amount * 2;
+
+const COLORS = {
+  ink: '#172033',
+  muted: '#5c677d',
+  green: { stroke: '#5d8f00', fill: '#d8f5a2' },
+  blue: { stroke: '#1971c2', fill: '#a5d8ff' },
+  violet: { stroke: '#862e9c', fill: '#eebefa' },
+  orange: { stroke: '#d9480f', fill: '#ffd8a8' },
+  red: { stroke: '#c92a2a', fill: '#ffc9c9' },
+  teal: { stroke: '#087f5b', fill: '#b2f2bb' },
+  gray: { stroke: '#495057', fill: '#e9ecef' },
+};
+
+const FONT = 'Chalkboard SE, Comic Sans MS, sans-serif';
+
+function roughLine(x1, y1, x2, y2, amount = 1.8) {
+  const middleX = (x1 + x2) / 2 + jitter(amount * 1.5);
+  const middleY = (y1 + y2) / 2 + jitter(amount * 1.5);
+  return `M ${(x1 + jitter(amount)).toFixed(1)} ${(y1 + jitter(amount)).toFixed(1)} Q ${middleX.toFixed(1)} ${middleY.toFixed(1)} ${(x2 + jitter(amount)).toFixed(1)} ${(y2 + jitter(amount)).toFixed(1)}`;
+}
+
+class Sketch {
+  constructor(width, height, background = '#ffffff') {
+    this.width = width;
+    this.height = height;
+    this.background = background;
+    this.parts = [];
+    this.defs = [];
+    this.clipId = 0;
+  }
+
+  add(value) {
+    this.parts.push(value);
+  }
+
+  rect(x, y, width, height, options = {}) {
+    const {
+      stroke = COLORS.ink,
+      fill,
+      strokeWidth = 2.4,
+      dashed = false,
+      hachure = true,
+      radius = 7,
+    } = options;
+
+    if (fill) {
+      if (hachure) {
+        const id = `hami-clip-${this.clipId++}`;
+        this.defs.push(`<clipPath id="${id}"><rect x="${x}" y="${y}" width="${width}" height="${height}" rx="${radius}"/></clipPath>`);
+        const hatch = [];
+        for (let offset = -height; offset < width; offset += 11) {
+          hatch.push(roughLine(x + offset, y + height, x + offset + height, y, 1));
+        }
+        this.add(`<path d="${hatch.join(' ')}" stroke="${fill}" stroke-width="2.5" opacity="0.58" fill="none" clip-path="url(#${id})" stroke-linecap="round"/>`);
+      } else {
+        this.add(`<rect x="${x}" y="${y}" width="${width}" height="${height}" rx="${radius}" fill="${fill}" fill-opacity="0.62"/>`);
+      }
+    }
+
+    const points = [[x, y], [x + width, y], [x + width, y + height], [x, y + height]];
+    for (let pass = 0; pass < 2; pass += 1) {
+      const path = points.map((point, index) => {
+        const next = points[(index + 1) % points.length];
+        return roughLine(point[0], point[1], next[0], next[1], pass === 0 ? 2 : 1.2);
+      }).join(' ');
+      this.add(`<path d="${path}" stroke="${stroke}" stroke-width="${pass === 0 ? strokeWidth : strokeWidth * 0.55}" opacity="${pass === 0 ? 1 : 0.55}" fill="none" stroke-linecap="round"${dashed ? ' stroke-dasharray="9 8"' : ''}/>`);
+    }
+  }
+
+  line(x1, y1, x2, y2, options = {}) {
+    const { stroke = COLORS.ink, strokeWidth = 2.4, dashed = false } = options;
+    this.add(`<path d="${roughLine(x1, y1, x2, y2)}" stroke="${stroke}" stroke-width="${strokeWidth}" fill="none" stroke-linecap="round"${dashed ? ' stroke-dasharray="8 8"' : ''}/>`);
+  }
+
+  arrow(x1, y1, x2, y2, options = {}) {
+    const { stroke = COLORS.ink, strokeWidth = 2.6, dashed = false } = options;
+    this.line(x1, y1, x2, y2, { stroke, strokeWidth, dashed });
+    const angle = Math.atan2(y2 - y1, x2 - x1);
+    const length = 14;
+    for (const offset of [Math.PI * 0.82, -Math.PI * 0.82]) {
+      this.line(
+        x2,
+        y2,
+        x2 + length * Math.cos(angle + offset),
+        y2 + length * Math.sin(angle + offset),
+        { stroke, strokeWidth }
+      );
+    }
+  }
+
+  text(x, y, value, options = {}) {
+    const {
+      size = 22,
+      color = COLORS.ink,
+      anchor = 'middle',
+      weight = 500,
+      family = FONT,
+    } = options;
+    const safe = String(value)
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;');
+    this.add(`<text x="${x}" y="${y}" font-family="${family}" font-size="${size}" font-weight="${weight}" fill="${color}" text-anchor="${anchor}">${safe}</text>`);
+  }
+
+  lines(x, y, values, options = {}) {
+    const lineHeight = (options.size || 22) * (options.lineHeight || 1.28);
+    values.forEach((value, index) => this.text(x, y + index * lineHeight, value, options));
+  }
+
+  circle(x, y, radius, options = {}) {
+    const { stroke = COLORS.ink, fill, strokeWidth = 2.4 } = options;
+    if (fill) this.add(`<circle cx="${x}" cy="${y}" r="${radius}" fill="${fill}" fill-opacity="0.65"/>`);
+    this.add(`<path d="M ${x - radius + jitter(1.5)} ${y} C ${x - radius} ${y - radius}, ${x + radius} ${y - radius}, ${x + radius + jitter(1.5)} ${y} C ${x + radius} ${y + radius}, ${x - radius} ${y + radius}, ${x - radius + jitter(1.5)} ${y}" stroke="${stroke}" stroke-width="${strokeWidth}" fill="none"/>`);
+  }
+
+  save(path) {
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="${this.width}" height="${this.height}" viewBox="0 0 ${this.width} ${this.height}">
+<defs>${this.defs.join('')}</defs>
+<rect width="${this.width}" height="${this.height}" fill="${this.background}"/>
+${this.parts.join('\n')}
+</svg>`;
+    writeFileSync(path, svg);
+  }
+}
+
+const output = process.argv[2] || '.';
+mkdirSync(output, { recursive: true });
+
+// Cover: a dedicated social-card aspect ratio, not a copy of an inline diagram.
+{
+  const sketch = new Sketch(1200, 630, '#f8fafc');
+  sketch.text(64, 68, 'KUBESIMPLIFY · GPU SHARING', { size: 19, anchor: 'start', weight: 800, color: COLORS.green.stroke });
+  sketch.lines(64, 158, ['Sharing GPUs in', 'Kubernetes with HAMi'], { size: 52, anchor: 'start', weight: 800, lineHeight: 1.12 });
+  sketch.lines(64, 292, ['Flexible memory and compute limits in software,', 'tested on an 8× RTX PRO 6000 Kubernetes node.'], { size: 22, anchor: 'start', color: COLORS.muted, lineHeight: 1.38 });
+
+  sketch.rect(70, 407, 515, 112, { stroke: COLORS.blue.stroke, fill: COLORS.blue.fill });
+  sketch.text(327, 449, '8 physical GPUs  →  80 scheduling slots', { size: 24, weight: 800, color: COLORS.blue.stroke });
+  sketch.text(327, 488, 'slots multiply · hardware capacity does not', { size: 18, color: COLORS.muted });
+
+  sketch.rect(720, 95, 390, 420, { stroke: COLORS.gray.stroke, fill: COLORS.gray.fill, strokeWidth: 3 });
+  sketch.text(915, 138, 'one physical GPU', { size: 26, weight: 800 });
+  sketch.text(915, 170, '97,887 MiB', { size: 20, color: COLORS.muted });
+
+  const pods = [
+    { x: 760, y: 212, w: 145, h: 105, memory: '8 GB', cores: '10%', color: COLORS.green },
+    { x: 925, y: 212, w: 145, h: 105, memory: '12 GB', cores: '20%', color: COLORS.blue },
+    { x: 760, y: 338, w: 145, h: 105, memory: '20 GB', cores: '25%', color: COLORS.orange },
+    { x: 925, y: 338, w: 145, h: 105, memory: '40 GB', cores: '45%', color: COLORS.violet },
+  ];
+  pods.forEach((pod, index) => {
+    sketch.rect(pod.x, pod.y, pod.w, pod.h, { stroke: pod.color.stroke, fill: pod.color.fill });
+    sketch.text(pod.x + pod.w / 2, pod.y + 35, `pod ${index + 1}`, { size: 19, weight: 800, color: pod.color.stroke });
+    sketch.text(pod.x + pod.w / 2, pod.y + 67, `${pod.memory} · ${pod.cores}`, { size: 17 });
+  });
+  sketch.text(915, 487, 'software-enforced boundaries', { size: 18, color: COLORS.muted });
+  sketch.text(64, 588, 'HAMi v2.9.0 · real commands · real OOM test', { size: 18, anchor: 'start', weight: 700, color: COLORS.orange.stroke });
+  sketch.save(join(output, 'cover.svg'));
+}
+
+// Architecture: scheduling and runtime enforcement are distinct stages.
+{
+  const sketch = new Sketch(1600, 920);
+  sketch.text(800, 62, 'What happens to one HAMi GPU request?', { size: 42, weight: 800 });
+  sketch.text(800, 100, 'placement first · injection second · enforcement while the process runs', { size: 22, color: COLORS.muted });
+
+  const topY = 170;
+  const topBoxes = [
+    { x: 65, title: 'Pod spec', lines: ['gpu: 1', 'gpumem: 8000', 'gpucores: 10'], color: COLORS.blue },
+    { x: 375, title: 'Webhook', lines: ['recognizes HAMi', 'resources and sets', 'schedulerName'], color: COLORS.violet },
+    { x: 685, title: 'Scheduler extender', lines: ['Filter: can it fit?', 'Score: which GPU?', 'Bind: write UUID'], color: COLORS.orange },
+    { x: 995, title: 'Pod annotation', lines: ['GPU UUID', '8000 MiB', '10% compute'], color: COLORS.teal },
+  ];
+
+  topBoxes.forEach((box, index) => {
+    sketch.rect(box.x, topY, 245, 205, { stroke: box.color.stroke, fill: box.color.fill });
+    sketch.text(box.x + 122, topY + 42, `${index + 1}. ${box.title}`, { size: 23, weight: 800, color: box.color.stroke });
+    sketch.lines(box.x + 122, topY + 88, box.lines, { size: 18, lineHeight: 1.35 });
+    if (index < topBoxes.length - 1) sketch.arrow(box.x + 252, topY + 102, topBoxes[index + 1].x - 10, topY + 102, { stroke: COLORS.ink });
+  });
+
+  sketch.arrow(1118, 385, 1118, 490, { stroke: COLORS.teal.stroke });
+
+  const bottomY = 510;
+  const bottomBoxes = [
+    { x: 995, title: 'Device plugin', lines: ['/dev/nvidia*', 'libvgpu.so', '/etc/ld.so.preload'], color: COLORS.teal },
+    { x: 685, title: 'Workload container', lines: ['normal PyTorch or', 'CUDA application', 'no code change'], color: COLORS.blue },
+    { x: 375, title: 'HAMi-Core', lines: ['tracks this container', 'returns OOM past', 'its memory grant'], color: COLORS.red },
+    { x: 65, title: 'Physical GPU', lines: ['accepted CUDA work', 'runs on the real', 'RTX PRO 6000'], color: COLORS.gray },
+  ];
+
+  bottomBoxes.forEach((box, index) => {
+    sketch.rect(box.x, bottomY, 245, 205, { stroke: box.color.stroke, fill: box.color.fill });
+    sketch.text(box.x + 122, bottomY + 42, `${index + 5}. ${box.title}`, { size: 23, weight: 800, color: box.color.stroke });
+    sketch.lines(box.x + 122, bottomY + 88, box.lines, { size: 18, lineHeight: 1.35 });
+    if (index < bottomBoxes.length - 1) sketch.arrow(box.x - 10, bottomY + 102, bottomBoxes[index + 1].x + 252, bottomY + 102, { stroke: COLORS.ink });
+  });
+
+  sketch.rect(1285, 178, 255, 190, { stroke: COLORS.orange.stroke, fill: COLORS.orange.fill, dashed: true });
+  sketch.text(1412, 219, 'Scheduling boundary', { size: 22, weight: 800, color: COLORS.orange.stroke });
+  sketch.lines(1412, 260, ['slot available?', 'memory available?', 'compute available?'], { size: 18, lineHeight: 1.45 });
+  sketch.arrow(1282, 275, 935, 275, { stroke: COLORS.orange.stroke, dashed: true });
+
+  sketch.rect(1285, 520, 255, 190, { stroke: COLORS.red.stroke, fill: COLORS.red.fill, dashed: true });
+  sketch.text(1412, 561, 'Runtime boundary', { size: 22, weight: 800, color: COLORS.red.stroke });
+  sketch.lines(1412, 602, ['CUDA/NVML paths', 'inside the process', 'software-enforced'], { size: 18, lineHeight: 1.45 });
+  sketch.arrow(1282, 615, 615, 615, { stroke: COLORS.red.stroke, dashed: true });
+
+  sketch.text(800, 855, 'The scheduler prevents over-commit at placement; HAMi-Core enforces the chosen grant at runtime.', { size: 23, color: COLORS.muted });
+  sketch.save(join(output, 'hami-architecture.svg'));
+}
+
+// Comparison: accurate boundaries for time-slicing, HAMi, and MIG.
+{
+  const sketch = new Sketch(1600, 790);
+  sketch.text(800, 62, 'Three ways to share one GPU', { size: 42, weight: 800 });
+  sketch.text(800, 100, 'same goal, very different isolation boundary', { size: 22, color: COLORS.muted });
+
+  const columns = [
+    { x: 75, title: 'Time-slicing', color: COLORS.orange, boundary: 'scheduler slots only', footer: ['no per-pod VRAM cap', 'all replicas see the full card'] },
+    { x: 590, title: 'HAMi', color: COLORS.green, boundary: 'user-space CUDA/NVML hooks', footer: ['arbitrary MiB + 1% core steps', 'best-effort software isolation'] },
+    { x: 1105, title: 'MIG', color: COLORS.blue, boundary: 'hardware partitions', footer: ['fixed profiles on supported GPUs', 'strong memory + compute isolation'] },
+  ];
+
+  columns.forEach((column) => {
+    sketch.text(column.x + 205, 155, column.title, { size: 30, weight: 800, color: column.color.stroke });
+    sketch.rect(column.x, 185, 410, 390, { stroke: COLORS.ink, strokeWidth: 3 });
+    sketch.text(column.x + 205, 222, column.boundary, { size: 18, color: COLORS.muted });
+
+    if (column.title === 'Time-slicing') {
+      ['pod A', 'pod B', 'pod C'].forEach((name, index) => {
+        sketch.rect(column.x + 50 + index * 108, 280, 92, 88, { stroke: column.color.stroke, fill: column.color.fill });
+        sketch.text(column.x + 96 + index * 108, 333, name, { size: 18, weight: 700 });
+      });
+      sketch.arrow(column.x + 75, 430, column.x + 335, 430, { stroke: column.color.stroke });
+      sketch.text(column.x + 205, 472, 'take turns on one open card', { size: 19 });
+    }
+
+    if (column.title === 'HAMi') {
+      const widths = [90, 135, 105];
+      let left = column.x + 32;
+      widths.forEach((width, index) => {
+        sketch.rect(left, 272, width, 180, { stroke: column.color.stroke, fill: column.color.fill, dashed: index === 1 });
+        sketch.text(left + width / 2, 325, `pod ${String.fromCharCode(65 + index)}`, { size: 17, weight: 700 });
+        sketch.text(left + width / 2, 360, ['8 GB', '20 GB', '12 GB'][index], { size: 18 });
+        sketch.text(left + width / 2, 392, ['10%', '35%', '15%'][index], { size: 17, color: COLORS.muted });
+        left += width + 13;
+      });
+      sketch.text(column.x + 205, 500, 'shared silicon, separate accounts', { size: 19 });
+    }
+
+    if (column.title === 'MIG') {
+      for (let row = 0; row < 2; row += 1) {
+        for (let col = 0; col < 2; col += 1) {
+          const x = column.x + 42 + col * 174;
+          const y = 262 + row * 125;
+          sketch.rect(x, y, 152, 105, { stroke: column.color.stroke, fill: column.color.fill, strokeWidth: 2.8 });
+          sketch.text(x + 76, y + 48, '1g.24gb', { size: 19, weight: 700 });
+          sketch.text(x + 76, y + 78, 'own SMs', { size: 16, color: COLORS.muted });
+        }
+      }
+      sketch.text(column.x + 205, 520, 'walls are built into the GPU', { size: 19 });
+    }
+
+    sketch.lines(column.x + 205, 630, column.footer, { size: 20, color: column.color.stroke, weight: 700, lineHeight: 1.45 });
+  });
+
+  sketch.text(800, 750, 'Choose flexibility, simplicity, or the strongest boundary based on the workload, not the buzzword.', { size: 23, color: COLORS.muted });
+  sketch.save(join(output, 'hami-isolation-spectrum.svg'));
+}
+
+console.log(`Wrote HAMi diagrams to ${output}`);
diff --git a/vercel.json b/vercel.json
index d579f42a0..9dd9cbdd9 100644
--- a/vercel.json
+++ b/vercel.json
@@ -876,6 +876,11 @@
       "destination": "https://blog.kubesimplify.com/ready-for-wasm-day-2023",
       "permanent": true
     },
+    {
+      "source": "/blog/sharing-gpus-in-kubernetes-with-hami",
+      "destination": "https://blog.kubesimplify.com/sharing-gpus-in-kubernetes-with-hami",
+      "permanent": true
+    },
     {
       "source": "/blog/simplified-introduction-to-bacalhau",
       "destination": "https://blog.kubesimplify.com/simplified-introduction-to-bacalhau",
@@ -2815,6 +2820,17 @@
         }
       ]
     },
+    {
+      "source": "/sharing-gpus-in-kubernetes-with-hami",
+      "destination": "https://blog.kubesimplify.com/sharing-gpus-in-kubernetes-with-hami",
+      "permanent": true,
+      "has": [
+        {
+          "type": "host",
+          "value": "kubesimplify.com"
+        }
+      ]
+    },
     {
       "source": "/simplified-introduction-to-bacalhau",
       "destination": "https://blog.kubesimplify.com/simplified-introduction-to-bacalhau",