feat: audio-synced promo video with richer visuals and tech explanations

Author: srpatcha

.github/workflows/video-build.yml

@@ -28,24 +28,25 @@ jobs:
         with:
           python-version: '3.11'
 
-      - name: Install Manim, gTTS & dependencies
+      - name: Install dependencies
         run: |
           sudo apt-get update
           sudo apt-get install -y ffmpeg libcairo2-dev libpango1.0-dev
-          pip install manim==0.18.1 gTTS
+          pip install manim==0.18.1 gTTS mutagen
 
-      - name: Generate narration audio
+      - name: Generate narration audio (per-segment)
         run: |
           cd promo
           python generate_audio.py
-          ls -lh narration.mp3
+          cat durations.json
+          ls -lh *.mp3
 
-      - name: Render promo video (1080p)
+      - name: Render synced promo video
         run: |
           cd promo
           manim render -qh --format mp4 promo_scene.py ProductPromo
 
-      - name: Merge video + audio into final MP4
+      - name: Merge video + audio
         run: |
           cd promo
           VIDEO=$(find media/videos -name "ProductPromo.mp4" | head -1)
@@ -54,7 +55,6 @@ jobs:
             -map 0:v:0 -map 1:a:0 \
             -shortest \
             ebuild_v1.0_promo.mp4
-          echo "Final video:"
           ls -lh ebuild_v1.0_promo.mp4
 
       - name: Upload final video
@@ -73,18 +73,3 @@ jobs:
           fail_on_unmatched_files: false
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  summary:
-    name: Video Build Summary
-    runs-on: ubuntu-latest
-    needs: render-video
-    if: always()
-    steps:
-      - name: Report
-        run: |
-          echo "## Promo Video Build" >> $GITHUB_STEP_SUMMARY
-          echo "| Detail | Value |" >> $GITHUB_STEP_SUMMARY
-          echo "|--------|-------|" >> $GITHUB_STEP_SUMMARY
-          echo "| Product | ebuild |" >> $GITHUB_STEP_SUMMARY
-          echo "| Audio | gTTS narration |" >> $GITHUB_STEP_SUMMARY
-          echo "| Render | ${{ needs.render-video.result }} |" >> $GITHUB_STEP_SUMMARY

promo/generate_audio.py

@@ -1,10 +1,45 @@
-"""Generate narration audio using Google Text-to-Speech."""
+"""Generate per-segment narration audio and output durations for Manim sync."""
+import json
 from gtts import gTTS
+from mutagen.mp3 import MP3
 
-NARRATION = (
-    "Introducing ebuild. The embedded build system for EoS. Feature one: Cross-compilation toolchains target any architecture from a single host. Feature two: Incremental builds compile only what changed, saving hours of build time. Feature three: Automatic dependency resolution manages complex embedded project graphs. ebuild. Open source and production ready. Visit github dot com slash embeddedos-org slash ebuild."
-)
+SEGMENTS = [
+    {"id": "intro", "text": "Introducing ebuild. EoS Embedded Build System."},
+    {"id": "f1", "text": "Feature one. Cross-Compilation Toolchains. Target ARM, RISC-V, and x86 from a single host with automatic toolchain management."},
+    {"id": "f2", "text": "Feature two. Incremental Builds. Content-addressed caching rebuilds only changed targets, cutting build times by 90 percent."},
+    {"id": "f3", "text": "Feature three. Dependency Resolution. DAG-based resolver handles diamond dependencies and circular includes automatically."},
+    {"id": "arch", "text": "Under the hood, ebuild is built with C, Make, CMake, LLVM. The architecture flows from Parser, to Resolver, to Scheduler, to Compiler, to Linker."},
+    {"id": "cta", "text": "ebuild. Open source and production ready. Visit github dot com slash embeddedos-org slash ebuild."},
+]
 
-tts = gTTS(text=NARRATION, lang="en", slow=False)
-tts.save("narration.mp3")
-print(f"Generated narration.mp3 ({len(NARRATION)} chars)")
+durations = {}
+audio_files = []
+
+for seg in SEGMENTS:
+    filename = f"seg_{seg['id']}.mp3"
+    tts = gTTS(text=seg["text"], lang="en", slow=False)
+    tts.save(filename)
+    dur = MP3(filename).info.length
+    durations[seg["id"]] = round(dur + 0.5, 1)  # add 0.5s padding
+    audio_files.append(filename)
+    print(f"  {seg['id']}: {dur:.1f}s -> padded {durations[seg['id']]}s")
+
+# Write durations JSON for Manim to read
+with open("durations.json", "w") as f:
+    json.dump(durations, f, indent=2)
+
+# Concatenate all segments into single narration.mp3
+import subprocess
+list_file = "concat_list.txt"
+with open(list_file, "w") as f:
+    for af in audio_files:
+        f.write(f"file '{af}'\n")
+
+subprocess.run([
+    "ffmpeg", "-y", "-f", "concat", "-safe", "0",
+    "-i", list_file, "-c", "copy", "narration.mp3"
+], check=True)
+
+total = sum(durations.values())
+print(f"\nTotal narration: {total:.1f}s")
+print(f"Durations: {json.dumps(durations)}")

promo/promo_scene.py

@@ -1,97 +1,167 @@
+"""ebuild — production promo video with synced narration."""
 from manim import *
+import json
+import os
 
+# Load durations from generate_audio.py
+dur_path = os.path.join(os.path.dirname(__file__), "durations.json")
+if os.path.exists(dur_path):
+    with open(dur_path) as f:
+        DUR = json.load(f)
+else:
+    DUR = {"intro": 4, "f1": 6, "f2": 6, "f3": 6, "arch": 7, "cta": 5}
+
+ACCENT = "#16a34a"
+BG = "#0f172a"
+DARK = "#1e293b"
 
-class ProductPromo(Scene):
-    """ebuild — promotional video."""
 
+class ProductPromo(Scene):
     def construct(self):
-        self.camera.background_color = "#0f172a"
-        accent = "#16a34a"
+        self.camera.background_color = BG
 
-        # ── Scene 1: Logo Reveal ──
+        # ═══ INTRO ═══
         title = Text("ebuild", font_size=96, color=WHITE, weight=BOLD)
-        tagline = Text(
-            "EoS Embedded Build System",
-            font_size=32, color=GRAY_B,
-        )
-        tagline.next_to(title, DOWN, buff=0.6)
+        underline = Line(LEFT * 3, RIGHT * 3, color=ACCENT, stroke_width=4)
+        underline.next_to(title, DOWN, buff=0.3)
+        tagline = Text("EoS Embedded Build System", font_size=28, color=GRAY_B)
+        tagline.next_to(underline, DOWN, buff=0.4)
+        # Tech badges
+        techs = "C, Make, CMake, LLVM".split(", ")
+        badges = VGroup()
+        for t in techs:
+            badge = VGroup(
+                RoundedRectangle(corner_radius=0.1, width=len(t)*0.18+0.6, height=0.4,
+                                 stroke_color=ACCENT, fill_color=DARK, fill_opacity=1),
+                Text(t, font_size=14, color=WHITE),
+            )
+            badge[1].move_to(badge[0])
+            badges.add(badge)
+        badges.arrange(RIGHT, buff=0.3).next_to(tagline, DOWN, buff=0.5)
 
-        self.play(Write(title), run_time=1.5)
-        self.play(FadeIn(tagline, shift=UP * 0.3), run_time=0.8)
-        self.wait(2)
-        self.play(FadeOut(title), FadeOut(tagline))
+        self.play(Write(title), run_time=0.8)
+        self.play(Create(underline), FadeIn(tagline, shift=UP*0.2), run_time=0.6)
+        self.play(LaggedStart(*[FadeIn(b, scale=0.8) for b in badges], lag_ratio=0.1), run_time=0.6)
+        self.wait(DUR["intro"] - 2.0)
+        self.play(FadeOut(VGroup(title, underline, tagline, badges)), run_time=0.4)
 
-        # ── Scene 2: Feature Showcase ──
+        # ═══ FEATURES ═══
         features = [
-            "Cross-Compilation Toolchains",
-            "Incremental Builds",
-            "Dependency Resolution",
+            ("01", "Cross-Compilation Toolchains", "Target ARM, RISC-V, and x86 from a single host with automatic toolchain management", DUR["f1"]),
+            ("02", "Incremental Builds", "Content-addressed caching rebuilds only changed targets, cutting build times by 90 percent", DUR["f2"]),
+            ("03", "Dependency Resolution", "DAG-based resolver handles diamond dependencies and circular includes automatically", DUR["f3"]),
         ]
-        for i, feat in enumerate(features):
-            num = Text(
-                f"0{i+1}", font_size=120, color=accent, weight=BOLD, font="Monospace",
-            ).set_opacity(0.15)
-            num.to_edge(LEFT, buff=1.5).shift(UP * 0.5)
+        for num, feat_name, feat_desc, dur in features:
+            # Large number watermark
+            num_text = Text(num, font_size=200, color=ACCENT, weight=BOLD,
+                           font="Monospace").set_opacity(0.08)
+            num_text.to_edge(LEFT, buff=0.5)
+
+            # Feature title
+            feat_title = Text(feat_name, font_size=48, color=WHITE, weight=BOLD)
+            feat_title.to_edge(UP, buff=1.5).shift(RIGHT * 0.5)
 
-            feat_text = Text(feat, font_size=52, color=WHITE, weight=BOLD)
-            feat_text.next_to(num, RIGHT, buff=0.8).align_to(num, UP)
+            # Accent bar
+            bar = Rectangle(width=6, height=0.05, color=ACCENT, fill_opacity=1)
+            bar.next_to(feat_title, DOWN, buff=0.2, aligned_edge=LEFT)
 
-            bar = Rectangle(
-                width=8, height=0.06, color=accent, fill_opacity=1,
+            # Description text (wrapped)
+            desc_text = Paragraph(
+                feat_desc, font_size=22, color=GRAY_B,
+                line_spacing=1.2, alignment="left",
+            ).scale(0.9)
+            desc_text.next_to(bar, DOWN, buff=0.4, aligned_edge=LEFT)
+            if desc_text.width > 10:
+                desc_text.scale(10 / desc_text.width)
+
+            # Visual element: tech diagram box
+            diagram = VGroup(
+                RoundedRectangle(corner_radius=0.15, width=4, height=2.5,
+                                 stroke_color=ACCENT, stroke_width=1,
+                                 fill_color=DARK, fill_opacity=0.5),
             )
-            bar.next_to(feat_text, DOWN, buff=0.3, aligned_edge=LEFT)
+            # Add icon-like dots inside
+            for row in range(3):
+                for col in range(4):
+                    dot = Dot(radius=0.04, color=ACCENT).set_opacity(0.3 + row*0.2)
+                    dot.move_to(diagram[0].get_center() + RIGHT*(col-1.5)*0.6 + DOWN*(row-1)*0.5)
+                    diagram.add(dot)
+            diagram.to_edge(RIGHT, buff=1).shift(DOWN * 0.3)
 
+            grp = VGroup(num_text, feat_title, bar, desc_text, diagram)
             self.play(
-                FadeIn(num, shift=RIGHT * 0.5),
-                Write(feat_text),
-                GrowFromEdge(bar, LEFT),
-                run_time=1.0,
+                FadeIn(num_text),
+                Write(feat_title), GrowFromEdge(bar, LEFT),
+                run_time=0.7,
             )
-            self.wait(1.5)
-            self.play(FadeOut(num), FadeOut(feat_text), FadeOut(bar), run_time=0.5)
+            self.play(FadeIn(desc_text, shift=UP*0.2), FadeIn(diagram, scale=0.9), run_time=0.6)
+            self.wait(dur - 1.7)
+            self.play(FadeOut(grp), run_time=0.4)
 
-        # ── Scene 3: Architecture Flash ──
-        arch_title = Text("Architecture", font_size=28, color=GRAY_B)
-        arch_title.to_edge(UP, buff=0.8)
+        # ═══ ARCHITECTURE ═══
+        arch_label = Text("Architecture", font_size=20, color=GRAY_B)
+        arch_label.to_edge(UP, buff=0.6)
 
+        components = ["Parser", "Resolver", "Scheduler", "Compiler", "Linker"]
         boxes = VGroup()
-        labels = ["Core", "API", "Runtime"]
-        for j, lbl in enumerate(labels):
-            box = RoundedRectangle(
-                corner_radius=0.15, width=2.5, height=1.2,
-                stroke_color=accent, fill_color="#1e293b", fill_opacity=1,
+        for i, comp in enumerate(components):
+            box = VGroup(
+                RoundedRectangle(
+                    corner_radius=0.12, width=2.2, height=1.0,
+                    stroke_color=ACCENT, fill_color=DARK, fill_opacity=1, stroke_width=2,
+                ),
+                Text(comp, font_size=16, color=WHITE),
             )
-            box_label = Text(lbl, font_size=22, color=WHITE)
-            box_label.move_to(box)
-            grp = VGroup(box, box_label)
-            boxes.add(grp)
-        boxes.arrange(RIGHT, buff=0.6)
+            box[1].move_to(box[0])
+            boxes.add(box)
+        boxes.arrange(RIGHT, buff=0.4)
 
         arrows = VGroup()
-        for j in range(len(boxes) - 1):
+        for i in range(len(boxes) - 1):
             arr = Arrow(
-                boxes[j].get_right(), boxes[j + 1].get_left(),
-                color=accent, buff=0.1, stroke_width=2,
+                boxes[i].get_right(), boxes[i+1].get_left(),
+                color=ACCENT, buff=0.08, stroke_width=2,
+                max_tip_length_to_length_ratio=0.15,
             )
             arrows.add(arr)
 
-        self.play(FadeIn(arch_title))
-        self.play(LaggedStart(*[FadeIn(b, shift=UP * 0.3) for b in boxes], lag_ratio=0.2))
-        self.play(LaggedStart(*[GrowArrow(a) for a in arrows], lag_ratio=0.15))
-        self.wait(2)
-        self.play(FadeOut(arch_title), FadeOut(boxes), FadeOut(arrows))
+        # Data flow dots
+        flow_dots = VGroup()
+        for arr in arrows:
+            for t in [0.3, 0.5, 0.7]:
+                dot = Dot(radius=0.03, color=ACCENT).set_opacity(0.6)
+                dot.move_to(arr.point_from_proportion(t))
+                flow_dots.add(dot)
 
-        # ── Scene 4: CTA ──
-        cta = Text("ebuild", font_size=72, color=WHITE, weight=BOLD)
-        url = Text(
+        self.play(FadeIn(arch_label), run_time=0.3)
+        self.play(
+            LaggedStart(*[FadeIn(b, shift=UP*0.3) for b in boxes], lag_ratio=0.12),
+            run_time=0.8,
+        )
+        self.play(
+            LaggedStart(*[GrowArrow(a) for a in arrows], lag_ratio=0.1),
+            run_time=0.5,
+        )
+        self.play(LaggedStart(*[FadeIn(d, scale=0) for d in flow_dots], lag_ratio=0.05), run_time=0.4)
+        self.wait(DUR["arch"] - 2.4)
+        self.play(FadeOut(VGroup(arch_label, boxes, arrows, flow_dots)), run_time=0.4)
+
+        # ═══ CTA ═══
+        cta_name = Text("ebuild", font_size=72, color=WHITE, weight=BOLD)
+        cta_line = Line(LEFT*2, RIGHT*2, color=ACCENT, stroke_width=3)
+        cta_line.next_to(cta_name, DOWN, buff=0.3)
+        cta_url = Text(
             "github.com/embeddedos-org/ebuild",
-            font_size=24, color=accent,
+            font_size=22, color=ManimColor(ACCENT),
         )
-        url.next_to(cta, DOWN, buff=0.5)
-        badge = Text("Open Source", font_size=18, color=GRAY_B)
-        badge.next_to(url, DOWN, buff=0.4)
-
-        self.play(Write(cta), run_time=1.0)
-        self.play(FadeIn(url, shift=UP * 0.2))
-        self.play(FadeIn(badge, shift=UP * 0.2))
-        self.wait(3)
+        cta_url.next_to(cta_line, DOWN, buff=0.3)
+        cta_badge = Text("Open Source  ·  MIT License  ·  Production Ready",
+                         font_size=16, color=GRAY_B)
+        cta_badge.next_to(cta_url, DOWN, buff=0.3)
+        star = Text("★  Star us on GitHub", font_size=18, color=YELLOW).set_opacity(0.8)
+        star.next_to(cta_badge, DOWN, buff=0.4)
+
+        self.play(Write(cta_name), Create(cta_line), run_time=0.7)
+        self.play(FadeIn(cta_url, shift=UP*0.2), run_time=0.4)
+        self.play(FadeIn(cta_badge), FadeIn(star), run_time=0.4)
+        self.wait(DUR["cta"] - 1.9)