chore: update demo

This commit is contained in:
Willie Hung
2026-01-21 10:11:13 +08:00
parent f60d46c4f5
commit ae194a8bb2
22 changed files with 4288 additions and 1 deletions
Binary file not shown.

Before

Width:  |  Height:  |  Size: 23 MiB

After

Width:  |  Height:  |  Size: 20 MiB

+4
View File
@@ -17,6 +17,10 @@ Thumbs.db
coverage.out
.claude/
AGENTS.md
CLAUDE.md
docs/plans/
# Worktrees
.worktrees/
video/node_modules/
+1 -1
View File
@@ -16,7 +16,7 @@
</p>
<p align="center">
<img src=".github/assets/demo.gif" alt="skillshare demo" width="600">
<img src=".github/assets/demo.gif" alt="skillshare demo" width="960">
</p>
<p align="center">
+23
View File
@@ -0,0 +1,23 @@
{
"name": "skillshare-promo-video",
"version": "1.0.0",
"description": "Skillshare promotional video built with Remotion",
"scripts": {
"dev": "remotion studio",
"build": "remotion render PromoVideo out/promo.mp4",
"preview": "remotion preview"
},
"keywords": [],
"author": "",
"license": "MIT",
"dependencies": {
"@remotion/bundler": "^4.0.407",
"@remotion/cli": "^4.0.407",
"@types/react": "^19.2.9",
"@types/react-dom": "^19.2.3",
"react": "^19.2.3",
"react-dom": "^19.2.3",
"remotion": "^4.0.407",
"typescript": "^5.9.3"
}
}
+1921
View File
File diff suppressed because it is too large Load Diff
Binary file not shown.

After

Width:  |  Height:  |  Size: 578 KiB

+60
View File
@@ -0,0 +1,60 @@
import { AbsoluteFill, Sequence } from 'remotion';
import { PainPoint } from './scenes/PainPoint';
import { TerminalDemo } from './scenes/TerminalDemo';
import { Architecture } from './scenes/Architecture';
import { TeamFeature } from './scenes/TeamFeature';
import { AIFeature } from './scenes/AIFeature';
import { ClosingLogo } from './scenes/ClosingLogo';
import { SceneWrapper } from './components/Transition3D';
import { colors } from './styles/colors';
const FPS = 30;
// 1.5x speed: 28s -> ~19s
export const PromoVideo = () => {
return (
<AbsoluteFill style={{ backgroundColor: colors.bgDark }}>
{/* Scene 1: Pain Point (0-3.3s) */}
<Sequence from={0} durationInFrames={3.3 * FPS}>
<SceneWrapper entranceType="zoomRotate" exitType="flipOut">
<PainPoint />
</SceneWrapper>
</Sequence>
{/* Scene 2: Terminal Demo (3.3-8.6s) */}
<Sequence from={3.3 * FPS} durationInFrames={5.3 * FPS}>
<SceneWrapper entranceType="slideUp" exitType="flipOut">
<TerminalDemo />
</SceneWrapper>
</Sequence>
{/* Scene 3: Architecture Diagram (8.6-11.3s) - shortened by 2s */}
<Sequence from={8.6 * FPS} durationInFrames={2.7 * FPS}>
<SceneWrapper entranceType="flipIn" exitType="flipOut">
<Architecture />
</SceneWrapper>
</Sequence>
{/* Scene 4: Team Feature (11.3-15.3s) */}
<Sequence from={11.3 * FPS} durationInFrames={4 * FPS}>
<SceneWrapper entranceType="slideUp" exitType="flipOut">
<TeamFeature />
</SceneWrapper>
</Sequence>
{/* Scene 5: AI Feature (15.3-19.3s) */}
<Sequence from={15.3 * FPS} durationInFrames={4 * FPS}>
<SceneWrapper entranceType="slideUp" exitType="fadeOut">
<AIFeature />
</SceneWrapper>
</Sequence>
{/* Scene 6: Closing Logo (19.3-22.3s) */}
<Sequence from={19.3 * FPS} durationInFrames={3 * FPS}>
<SceneWrapper entranceType="zoomRotate" exitType="none">
<ClosingLogo />
</SceneWrapper>
</Sequence>
</AbsoluteFill>
);
};
+81
View File
@@ -0,0 +1,81 @@
import { Composition, Folder } from 'remotion';
import { PromoVideo } from './PromoVideo';
import { PainPoint } from './scenes/PainPoint';
import { TerminalDemo } from './scenes/TerminalDemo';
import { Architecture } from './scenes/Architecture';
import { TeamFeature } from './scenes/TeamFeature';
import { AIFeature } from './scenes/AIFeature';
import { ClosingLogo } from './scenes/ClosingLogo';
// Video specs
const FPS = 30;
const WIDTH = 1920;
const HEIGHT = 1080;
export const RemotionRoot = () => {
return (
<>
{/* Main promo video - 22.3 seconds */}
<Composition
id="PromoVideo"
component={PromoVideo}
durationInFrames={22.3 * FPS}
fps={FPS}
width={WIDTH}
height={HEIGHT}
/>
{/* Individual scenes for preview/testing */}
<Folder name="Scenes">
<Composition
id="Scene1-PainPoint"
component={PainPoint}
durationInFrames={3.3 * FPS}
fps={FPS}
width={WIDTH}
height={HEIGHT}
/>
<Composition
id="Scene2-TerminalDemo"
component={TerminalDemo}
durationInFrames={5.3 * FPS}
fps={FPS}
width={WIDTH}
height={HEIGHT}
/>
<Composition
id="Scene3-Architecture"
component={Architecture}
durationInFrames={2.7 * FPS}
fps={FPS}
width={WIDTH}
height={HEIGHT}
/>
<Composition
id="Scene4-TeamFeature"
component={TeamFeature}
durationInFrames={4 * FPS}
fps={FPS}
width={WIDTH}
height={HEIGHT}
/>
<Composition
id="Scene5-AIFeature"
component={AIFeature}
durationInFrames={4 * FPS}
fps={FPS}
width={WIDTH}
height={HEIGHT}
/>
<Composition
id="Scene6-ClosingLogo"
component={ClosingLogo}
durationInFrames={3 * FPS}
fps={FPS}
width={WIDTH}
height={HEIGHT}
/>
</Folder>
</>
);
};
+119
View File
@@ -0,0 +1,119 @@
import { useCurrentFrame, useVideoConfig, spring, interpolate } from 'remotion';
import { colors } from '../styles/colors';
export type AIToolName = 'claude' | 'opencode' | 'codex' | 'antigravity';
type AIIconProps = {
name: AIToolName;
size?: number;
enterDelay?: number;
showLabel?: boolean;
labelText?: string;
};
const toolColors: Record<AIToolName, string> = {
claude: '#d97706', // Orange/amber
opencode: '#3b82f6', // Blue
codex: '#10a37f', // Green
antigravity: '#8b5cf6', // Purple
};
const toolLabels: Record<AIToolName, string> = {
claude: 'Claude',
opencode: 'OpenCode',
codex: 'Codex',
antigravity: 'Antigravity',
};
const toolPaths: Record<AIToolName, string> = {
claude: '~/.claude/skills',
opencode: '~/.config/opencode/skills',
codex: '~/.codex/skills',
antigravity: '~/.gemini/antigravity/skills',
};
export const AIIcon = ({
name,
size = 80,
enterDelay = 0,
showLabel = true,
labelText,
}: AIIconProps) => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const entrance = spring({
frame: frame - enterDelay,
fps,
config: { damping: 12, stiffness: 100 },
});
const scale = interpolate(entrance, [0, 1], [0, 1]);
const opacity = interpolate(entrance, [0, 1], [0, 1], {
extrapolateRight: 'clamp',
});
const bgColor = toolColors[name];
return (
<div
style={{
display: 'flex',
flexDirection: 'column',
alignItems: 'flex-start',
gap: '8px',
transform: `scale(${scale})`,
opacity,
}}
>
<div
style={{
width: size,
height: size,
borderRadius: '16px',
backgroundColor: bgColor,
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
justifyContent: 'center',
gap: 4,
boxShadow: `0 4px 16px rgba(0, 0, 0, 0.3), 0 0 20px ${bgColor}30`,
}}
>
{/* Folder icon */}
<svg width={size * 0.45} height={size * 0.45} viewBox="0 0 24 24" fill="none">
<path
d="M3 7V17C3 18.1046 3.89543 19 5 19H19C20.1046 19 21 18.1046 21 17V9C21 7.89543 20.1046 7 19 7H13L11 5H5C3.89543 5 3 5.89543 3 7Z"
fill="rgba(255, 255, 255, 0.25)"
stroke="rgba(255, 255, 255, 0.9)"
strokeWidth="1.5"
strokeLinecap="round"
strokeLinejoin="round"
/>
</svg>
<span
style={{
color: '#fff',
fontSize: size * 0.15,
fontWeight: 600,
fontFamily: '-apple-system, BlinkMacSystemFont, sans-serif',
textShadow: '0 1px 2px rgba(0,0,0,0.3)',
}}
>
{toolLabels[name]}
</span>
</div>
{showLabel && (
<span
style={{
color: colors.textSecondary,
fontSize: '14px',
fontFamily: '"JetBrains Mono", monospace',
}}
>
{labelText || toolPaths[name]}
</span>
)}
</div>
);
};
+29
View File
@@ -0,0 +1,29 @@
import { useCurrentFrame, useVideoConfig, interpolate } from 'remotion';
import { colors } from '../styles/colors';
type CursorProps = {
blinkInterval?: number; // in frames
color?: string;
};
export const Cursor = ({ blinkInterval = 15, color = colors.terminalText }: CursorProps) => {
const frame = useCurrentFrame();
// Create blinking effect using modulo
const cyclePosition = frame % (blinkInterval * 2);
const opacity = cyclePosition < blinkInterval ? 1 : 0;
return (
<span
style={{
display: 'inline-block',
width: '10px',
height: '22px',
backgroundColor: color,
opacity,
verticalAlign: 'middle',
marginLeft: '2px',
}}
/>
);
};
+110
View File
@@ -0,0 +1,110 @@
import { AbsoluteFill, useCurrentFrame, useVideoConfig, spring, interpolate } from 'remotion';
import { colors } from '../styles/colors';
import { ReactNode } from 'react';
type MacTerminalProps = {
children: ReactNode;
title?: string;
width?: number;
enterDelay?: number;
};
export const MacTerminal = ({
children,
title = 'skillshare',
width = 1000,
enterDelay = 0,
}: MacTerminalProps) => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
// Spring animation for entrance
const entrance = spring({
frame: frame - enterDelay,
fps,
config: { damping: 15, stiffness: 100 },
});
const scale = interpolate(entrance, [0, 1], [0.9, 1]);
const translateY = interpolate(entrance, [0, 1], [50, 0]);
const opacity = interpolate(entrance, [0, 1], [0, 1], {
extrapolateRight: 'clamp',
});
return (
<div
style={{
width,
borderRadius: '12px',
overflow: 'hidden',
boxShadow: '0 25px 50px -12px rgba(0, 0, 0, 0.5)',
transform: `scale(${scale}) translateY(${translateY}px)`,
opacity,
}}
>
{/* Title bar */}
<div
style={{
backgroundColor: '#e5e5e5',
padding: '12px 16px',
display: 'flex',
alignItems: 'center',
gap: '8px',
}}
>
{/* Traffic lights */}
<div style={{ display: 'flex', gap: '8px' }}>
<div
style={{
width: '14px',
height: '14px',
borderRadius: '50%',
backgroundColor: colors.trafficRed,
}}
/>
<div
style={{
width: '14px',
height: '14px',
borderRadius: '50%',
backgroundColor: colors.trafficYellow,
}}
/>
<div
style={{
width: '14px',
height: '14px',
borderRadius: '50%',
backgroundColor: colors.trafficGreen,
}}
/>
</div>
{/* Title */}
<div
style={{
flex: 1,
textAlign: 'center',
fontFamily: '-apple-system, BlinkMacSystemFont, sans-serif',
fontSize: '14px',
color: '#666',
marginRight: '54px', // Balance the traffic lights
}}
>
{title}
</div>
</div>
{/* Terminal content */}
<div
style={{
backgroundColor: colors.terminalBg,
padding: '24px',
minHeight: '300px',
}}
>
{children}
</div>
</div>
);
};
+262
View File
@@ -0,0 +1,262 @@
import { ReactNode } from 'react';
import { useCurrentFrame, useVideoConfig, spring, interpolate } from 'remotion';
type Transition3DProps = {
children: ReactNode;
type?: 'slideUp' | 'flipIn' | 'flipOut' | 'zoomRotate';
delay?: number;
duration?: number;
};
export const Transition3D = ({
children,
type = 'slideUp',
delay = 0,
duration,
}: Transition3DProps) => {
const frame = useCurrentFrame();
const { fps, durationInFrames } = useVideoConfig();
const effectiveDuration = duration ?? durationInFrames;
// Slide up entrance with 3D rotation
if (type === 'slideUp') {
const entrance = spring({
frame: frame - delay,
fps,
config: { damping: 200, stiffness: 100 },
});
const translateY = interpolate(entrance, [0, 1], [400, 0]);
const rotateX = interpolate(entrance, [0, 1], [30, 0]);
const scale = interpolate(entrance, [0, 1], [0.8, 1]);
const opacity = interpolate(entrance, [0, 1], [0, 1], {
extrapolateRight: 'clamp',
});
return (
<div
style={{
width: '100%',
height: '100%',
perspective: 1000,
}}
>
<div
style={{
width: '100%',
height: '100%',
transform: `translateY(${translateY}px) rotateX(${rotateX}deg) scale(${scale})`,
opacity,
transformOrigin: 'center bottom',
}}
>
{children}
</div>
</div>
);
}
// Flip in from top
if (type === 'flipIn') {
const entrance = spring({
frame: frame - delay,
fps,
config: { damping: 15, stiffness: 80 },
});
const rotateX = interpolate(entrance, [0, 1], [-90, 0]);
const opacity = interpolate(entrance, [0, 1], [0, 1], {
extrapolateRight: 'clamp',
});
return (
<div
style={{
width: '100%',
height: '100%',
perspective: 1200,
}}
>
<div
style={{
width: '100%',
height: '100%',
transform: `rotateX(${rotateX}deg)`,
opacity,
transformOrigin: 'center top',
}}
>
{children}
</div>
</div>
);
}
// Flip out to bottom
if (type === 'flipOut') {
const exitStart = effectiveDuration - 0.5 * fps;
const exitProgress = interpolate(frame, [exitStart, effectiveDuration], [0, 1], {
extrapolateLeft: 'clamp',
extrapolateRight: 'clamp',
});
const rotateX = interpolate(exitProgress, [0, 1], [0, 90]);
const opacity = interpolate(exitProgress, [0, 1], [1, 0]);
return (
<div
style={{
width: '100%',
height: '100%',
perspective: 1200,
}}
>
<div
style={{
width: '100%',
height: '100%',
transform: `rotateX(${rotateX}deg)`,
opacity,
transformOrigin: 'center bottom',
}}
>
{children}
</div>
</div>
);
}
// Zoom with subtle rotation throughout
if (type === 'zoomRotate') {
const entrance = spring({
frame: frame - delay,
fps,
config: { damping: 200, stiffness: 100 },
});
// Continuous subtle Y rotation
const rotateY = interpolate(frame, [0, effectiveDuration], [8, -8]);
const scale = interpolate(entrance, [0, 1], [0.9, 1]);
const opacity = interpolate(entrance, [0, 1], [0, 1], {
extrapolateRight: 'clamp',
});
return (
<div
style={{
width: '100%',
height: '100%',
perspective: 1000,
}}
>
<div
style={{
width: '100%',
height: '100%',
transform: `scale(${scale}) rotateY(${rotateY}deg)`,
opacity,
transformOrigin: 'center center',
}}
>
{children}
</div>
</div>
);
}
return <>{children}</>;
};
// Scene wrapper with entrance and exit transitions
type SceneWrapperProps = {
children: ReactNode;
entranceType?: 'slideUp' | 'flipIn' | 'zoomRotate';
exitType?: 'flipOut' | 'fadeOut' | 'none';
entranceDelay?: number;
};
export const SceneWrapper = ({
children,
entranceType = 'slideUp',
exitType = 'flipOut',
entranceDelay = 0,
}: SceneWrapperProps) => {
const frame = useCurrentFrame();
const { fps, durationInFrames } = useVideoConfig();
// Entrance animation
const entrance = spring({
frame: frame - entranceDelay,
fps,
config: { damping: 200, stiffness: 100 },
});
// Exit animation (last 0.4s)
const exitStart = durationInFrames - 0.4 * fps;
const exitProgress = interpolate(frame, [exitStart, durationInFrames], [0, 1], {
extrapolateLeft: 'clamp',
extrapolateRight: 'clamp',
});
// Entrance transforms
let entranceTransform = '';
let entranceOpacity = 1;
if (entranceType === 'slideUp') {
const translateY = interpolate(entrance, [0, 1], [300, 0]);
const rotateX = interpolate(entrance, [0, 1], [20, 0]);
const scale = interpolate(entrance, [0, 1], [0.85, 1]);
entranceTransform = `translateY(${translateY}px) rotateX(${rotateX}deg) scale(${scale})`;
entranceOpacity = interpolate(entrance, [0, 1], [0, 1], { extrapolateRight: 'clamp' });
} else if (entranceType === 'flipIn') {
const rotateX = interpolate(entrance, [0, 1], [-60, 0]);
entranceTransform = `rotateX(${rotateX}deg)`;
entranceOpacity = interpolate(entrance, [0, 1], [0, 1], { extrapolateRight: 'clamp' });
} else if (entranceType === 'zoomRotate') {
const scale = interpolate(entrance, [0, 1], [0.9, 1]);
const rotateY = interpolate(entrance, [0, 1], [15, 0]);
entranceTransform = `scale(${scale}) rotateY(${rotateY}deg)`;
entranceOpacity = interpolate(entrance, [0, 1], [0, 1], { extrapolateRight: 'clamp' });
}
// Exit transforms
let exitTransform = '';
let exitOpacity = 1;
if (exitType === 'flipOut' && exitProgress > 0) {
const rotateX = interpolate(exitProgress, [0, 1], [0, -60]);
const scale = interpolate(exitProgress, [0, 1], [1, 0.9]);
exitTransform = `rotateX(${rotateX}deg) scale(${scale})`;
exitOpacity = interpolate(exitProgress, [0, 1], [1, 0]);
} else if (exitType === 'fadeOut' && exitProgress > 0) {
const scale = interpolate(exitProgress, [0, 1], [1, 1.05]);
exitTransform = `scale(${scale})`;
exitOpacity = interpolate(exitProgress, [0, 1], [1, 0]);
}
const finalOpacity = entranceOpacity * exitOpacity;
const finalTransform = exitProgress > 0 ? exitTransform : entranceTransform;
return (
<div
style={{
width: '100%',
height: '100%',
perspective: 1200,
}}
>
<div
style={{
width: '100%',
height: '100%',
transform: finalTransform,
opacity: finalOpacity,
transformOrigin: 'center center',
}}
>
{children}
</div>
</div>
);
};
+51
View File
@@ -0,0 +1,51 @@
import { useCurrentFrame, useVideoConfig } from 'remotion';
import { Cursor } from './Cursor';
import { colors } from '../styles/colors';
type TypewriterProps = {
text: string;
startFrame?: number;
speed?: number; // frames per character
showCursor?: boolean;
prefix?: string;
color?: string;
style?: React.CSSProperties;
showPrompt?: boolean;
};
export const Typewriter = ({
text,
startFrame = 0,
speed = 2, // 2 frames per character (~66ms at 30fps)
showCursor = true,
prefix = '$ ',
color = colors.terminalText,
style,
showPrompt = true,
}: TypewriterProps) => {
const frame = useCurrentFrame();
const elapsed = Math.max(0, frame - startFrame);
const charsToShow = Math.floor(elapsed / speed);
const visibleText = text.slice(0, charsToShow);
const isTyping = charsToShow < text.length && elapsed > 0;
const isDone = charsToShow >= text.length;
const finalColor = style?.color || color;
return (
<div
style={{
fontFamily: '"JetBrains Mono", "SF Mono", monospace',
fontSize: '24px',
color: finalColor,
whiteSpace: 'pre',
...style,
}}
>
{showPrompt && <span style={{ color: colors.terminalGreen }}>{prefix}</span>}
{visibleText}
{showCursor && (isTyping || isDone) && <Cursor color={finalColor} />}
</div>
);
};
+4
View File
@@ -0,0 +1,4 @@
import { registerRoot } from 'remotion';
import { RemotionRoot } from './Root';
registerRoot(RemotionRoot);
+322
View File
@@ -0,0 +1,322 @@
import { AbsoluteFill, useCurrentFrame, useVideoConfig, spring, interpolate } from 'remotion';
import { Typewriter } from '../components/Typewriter';
import { colors } from '../styles/colors';
const FPS = 30;
// Claude brand orange color
const CLAUDE_ORANGE = '#d97706';
export const AIFeature = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
// Timeline (4s):
// 0-0.3s: Title flies in
// 0.3-0.5s: Chat container appears
// 0.5-2.2s: User message types (34 chars * 1.5 speed = ~1.7s)
// 2.4s: Claude response row + thinking
// 3.0s: Claude executes command
// 3.5s: Success message
// 4s: Hold
// Calculate when user typing finishes
const userText = "Sync my skills to all my AI tools";
const typeSpeed = 1.0; // faster typing
const typeStartFrame = 0.5 * fps;
const typeEndFrame = typeStartFrame + userText.length * typeSpeed; // ~49 frames = 1.6s
// Title entrance
const titleEntrance = spring({
frame,
fps,
config: { damping: 12, stiffness: 150 },
});
// Chat container entrance
const chatEntrance = spring({
frame: frame - 0.3 * fps,
fps,
config: { damping: 15 },
});
// User message entrance
const userMsgEntrance = spring({
frame: frame - 0.5 * fps,
fps,
config: { damping: 15 },
});
// Claude response entrance - wait for user to finish typing
const claudeResponseEntrance = spring({
frame: frame - (typeEndFrame + 3), // 3 frames after typing ends
fps,
config: { damping: 12 },
});
// Command execution - after thinking for a bit
const commandEntrance = spring({
frame: frame - (typeEndFrame + 12), // ~0.4s after Claude appears
fps,
config: { damping: 12 },
});
// Success checkmark with bouncy entrance
const successEntrance = spring({
frame: frame - (typeEndFrame + 22), // ~0.7s after Claude appears
fps,
config: { damping: 8, stiffness: 180 },
});
// Success glow pulse
const successGlowPhase = (frame - (typeEndFrame + 27)) * 0.12;
const successGlowIntensity = successEntrance > 0.8 ? 16 + 12 * Math.sin(successGlowPhase) : 16;
return (
<AbsoluteFill style={{ backgroundColor: colors.bgDark }}>
{/* Main title */}
<div
style={{
position: 'absolute',
top: 60,
left: '50%',
transform: `translateX(-50%) scale(${titleEntrance}) translateY(${(1 - titleEntrance) * -30}px)`,
}}
>
<h1
style={{
fontFamily: '-apple-system, BlinkMacSystemFont, sans-serif',
fontSize: '64px',
fontWeight: 700,
color: colors.textPrimary,
margin: 0,
textShadow: `0 0 60px ${colors.primary}60`,
}}
>
Built-in AI
</h1>
</div>
{/* Claude-style Chat interface */}
<div
style={{
position: 'absolute',
top: '50%',
left: '50%',
transform: `translate(-50%, -50%) scale(${chatEntrance})`,
opacity: chatEntrance,
width: 1200,
backgroundColor: '#1c1c1c',
borderRadius: 20,
overflow: 'hidden',
boxShadow: '0 25px 80px rgba(0,0,0,0.6)',
}}
>
{/* User message row */}
<div
style={{
backgroundColor: '#2a2a2a',
padding: '36px 50px',
borderBottom: '1px solid #4a4a4a',
opacity: userMsgEntrance,
transform: `translateY(${(1 - userMsgEntrance) * 10}px)`,
}}
>
<div style={{ display: 'flex', alignItems: 'flex-start', gap: 24 }}>
{/* User avatar */}
<div
style={{
width: 48,
height: 48,
borderRadius: '50%',
backgroundColor: '#5a5a5a',
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
flexShrink: 0,
}}
>
<svg width="24" height="24" viewBox="0 0 24 24" fill="none">
<circle cx="12" cy="8" r="4" fill="#aaa" />
<path d="M4 20c0-4 4-6 8-6s8 2 8 6" stroke="#aaa" strokeWidth="2" strokeLinecap="round" />
</svg>
</div>
{/* User message */}
<div style={{ flex: 1, paddingTop: 8 }}>
<Typewriter
text={userText}
startFrame={typeStartFrame}
speed={typeSpeed}
showCursor={false}
showPrompt={false}
style={{
color: '#ffffff',
fontSize: '32px',
fontWeight: 500,
fontFamily: '-apple-system, BlinkMacSystemFont, sans-serif',
lineHeight: 1.5,
}}
/>
</div>
</div>
</div>
{/* Claude response row */}
{claudeResponseEntrance > 0 && (
<div
style={{
backgroundColor: '#1c1c1c',
padding: '36px 50px',
opacity: claudeResponseEntrance,
transform: `translateY(${(1 - claudeResponseEntrance) * 10}px)`,
}}
>
<div style={{ display: 'flex', alignItems: 'flex-start', gap: 24 }}>
{/* Claude avatar */}
<div
style={{
width: 48,
height: 48,
borderRadius: 12,
background: `linear-gradient(135deg, ${CLAUDE_ORANGE}, #f59e0b)`,
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
flexShrink: 0,
boxShadow: `0 4px 12px ${CLAUDE_ORANGE}40`,
}}
>
<ClaudeLogo />
</div>
{/* Claude message content */}
<div style={{ flex: 1, paddingTop: 4 }}>
{commandEntrance > 0 ? (
<div style={{ display: 'flex', flexDirection: 'column', gap: 24 }}>
{/* Response text */}
<span
style={{
color: '#ffffff',
fontSize: '28px',
fontFamily: '-apple-system, BlinkMacSystemFont, sans-serif',
lineHeight: 1.6,
}}
>
I'll sync your skills now. Running the command:
</span>
{/* Code block - Claude style */}
<div
style={{
backgroundColor: '#0d0d0d',
borderRadius: 10,
padding: '20px 28px',
border: '1px solid #444',
transform: `scale(${commandEntrance})`,
transformOrigin: 'left',
}}
>
<code
style={{
fontFamily: '"JetBrains Mono", "SF Mono", monospace',
fontSize: '26px',
color: '#4ade80',
}}
>
$ skillshare sync
</code>
</div>
{/* Success message */}
{successEntrance > 0 && (
<div
style={{
display: 'flex',
alignItems: 'center',
gap: 14,
transform: `scale(${successEntrance})`,
transformOrigin: 'left',
}}
>
<div
style={{
width: 32,
height: 32,
borderRadius: '50%',
backgroundColor: '#22c55e',
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
boxShadow: `0 0 ${successGlowIntensity}px #22c55e80`,
}}
>
<span style={{ color: '#fff', fontSize: '18px', fontWeight: 'bold' }}>✓</span>
</div>
<span
style={{
color: '#4ade80',
fontSize: '26px',
fontFamily: '-apple-system, BlinkMacSystemFont, sans-serif',
fontWeight: 600,
}}
>
Synced 5 skills to 4 AI tools
</span>
</div>
)}
</div>
) : (
<ThinkingIndicator />
)}
</div>
</div>
</div>
)}
</div>
</AbsoluteFill>
);
};
// Claude sparkle logo (simplified)
const ClaudeLogo = () => (
<svg width="22" height="22" viewBox="0 0 24 24" fill="none">
<path
d="M12 2L14.5 9.5L22 12L14.5 14.5L12 22L9.5 14.5L2 12L9.5 9.5L12 2Z"
fill="#fff"
opacity="0.95"
/>
</svg>
);
// Claude-style thinking indicator
const ThinkingIndicator = () => {
const frame = useCurrentFrame();
// Pulsing animation
const pulse = Math.sin(frame * 0.15) * 0.5 + 0.5;
return (
<div style={{ display: 'flex', alignItems: 'center', gap: 12 }}>
{/* Pulsing cursor */}
<div
style={{
width: 3,
height: 24,
backgroundColor: CLAUDE_ORANGE,
borderRadius: 2,
opacity: 0.4 + pulse * 0.6,
}}
/>
<span
style={{
color: '#888',
fontSize: '18px',
fontFamily: '-apple-system, BlinkMacSystemFont, sans-serif',
fontStyle: 'italic',
}}
>
Thinking...
</span>
</div>
);
};
+359
View File
@@ -0,0 +1,359 @@
import { AbsoluteFill, useCurrentFrame, useVideoConfig, spring, interpolate, Easing } from 'remotion';
import { AIIcon, AIToolName } from '../components/AIIcon';
import { colors } from '../styles/colors';
const FPS = 30;
// Target positions arranged in a circle around center (4 tools)
const targetPositions: { name: AIToolName; angle: number; delay: number }[] = [
{ name: 'claude', angle: -90, delay: 0 },
{ name: 'opencode', angle: 0, delay: 4 },
{ name: 'codex', angle: 90, delay: 8 },
{ name: 'antigravity', angle: 180, delay: 12 },
];
const RADIUS = 280;
const CENTER_X = 960;
const CENTER_Y = 420; // Move up to make room for text
export const Architecture = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
// Timeline (compressed to 2.7s):
// 0-0.4s: Source block appears with label
// 0.4-1s: Targets fly in
// 1-1.6s: Arrows animate
// 1.3s: Checkmarks start appearing
// 1.5-1.8s: "All in sync" text fades in
// 1.8-2.7s: Full display (0.9s visibility)
// Source entrance
const sourceEntrance = spring({
frame,
fps,
config: { damping: 15, stiffness: 200 },
});
// Source breathing pulse effect (continuous after entrance)
const breathePhase = (frame - 0.3 * fps) * 0.08;
const breatheScale = sourceEntrance > 0.9 ? 1 + 0.03 * Math.sin(breathePhase) : sourceEntrance;
const breatheGlow = sourceEntrance > 0.9 ? 60 + 30 * Math.sin(breathePhase) : 60 * sourceEntrance;
// Source label with spring entrance
const labelEntrance = spring({
frame: frame - 0.2 * fps,
fps,
config: { damping: 12, stiffness: 150 },
});
const labelOpacity = interpolate(labelEntrance, [0, 1], [0, 1], {
extrapolateRight: 'clamp',
});
const labelTranslateY = interpolate(labelEntrance, [0, 1], [15, 0], {
extrapolateRight: 'clamp',
});
// Arrow animation (1-1.8s)
const arrowStart = 1 * fps;
const arrowProgress = interpolate(frame, [arrowStart, arrowStart + 0.6 * fps], [0, 1], {
extrapolateLeft: 'clamp',
extrapolateRight: 'clamp',
easing: Easing.out(Easing.quad),
});
// Checkmark animation (1.3-2.7s, earlier for more impact)
const checkStart = 1.3 * fps;
const checkProgress = spring({
frame: frame - checkStart,
fps,
config: { damping: 12 },
});
// "All in sync" text with spring entrance
const syncTextEntrance = spring({
frame: frame - 1.5 * fps,
fps,
config: { damping: 12, stiffness: 150 },
});
const syncTextOpacity = interpolate(syncTextEntrance, [0, 1], [0, 1], {
extrapolateRight: 'clamp',
});
const syncTextScale = interpolate(syncTextEntrance, [0, 1], [0.8, 1], {
extrapolateRight: 'clamp',
});
// Particle flow along arrows (continuous after arrows appear)
const particleCycleDuration = 40; // frames per cycle
const getParticlePosition = (angle: number, particleIndex: number) => {
if (arrowProgress < 0.5) return null;
const cycleOffset = particleIndex * (particleCycleDuration / 3);
const cycleProgress = ((frame - arrowStart + cycleOffset) % particleCycleDuration) / particleCycleDuration;
const targetPos = getTargetPosition(angle);
const targetX = targetPos.x + 45;
const targetY = targetPos.y + 45;
// Particle moves from center to target
const particleX = CENTER_X + (targetX - CENTER_X) * cycleProgress;
const particleY = CENTER_Y + (targetY - CENTER_Y) * cycleProgress;
const particleOpacity = interpolate(cycleProgress, [0, 0.3, 0.7, 1], [0, 1, 1, 0]);
return { x: particleX, y: particleY, opacity: particleOpacity };
};
// Calculate target positions
const getTargetPosition = (angle: number) => {
const rad = (angle * Math.PI) / 180;
return {
x: CENTER_X + RADIUS * Math.cos(rad) - 45,
y: CENTER_Y + RADIUS * Math.sin(rad) - 45,
};
};
return (
<AbsoluteFill style={{ backgroundColor: colors.bgDark }}>
{/* Source block (center) - Glassmorphism style */}
<div
style={{
position: 'absolute',
left: CENTER_X - 80,
top: CENTER_Y - 80,
transform: `scale(${breatheScale})`,
}}
>
{/* Glow layer behind */}
<div
style={{
position: 'absolute',
inset: -20,
borderRadius: '50%',
background: `radial-gradient(circle, ${colors.primary}40 0%, transparent 70%)`,
filter: `blur(${breatheGlow * 0.3}px)`,
}}
/>
{/* Glass card */}
<div
style={{
position: 'relative',
width: 160,
height: 160,
borderRadius: '28px',
background: `linear-gradient(135deg, rgba(99, 102, 241, 0.25) 0%, rgba(99, 102, 241, 0.1) 100%)`,
backdropFilter: 'blur(20px)',
WebkitBackdropFilter: 'blur(20px)',
border: '1px solid rgba(255, 255, 255, 0.18)',
boxShadow: `
0 8px 32px rgba(0, 0, 0, 0.3),
0 0 ${breatheGlow}px ${colors.primary}30,
inset 0 1px 0 rgba(255, 255, 255, 0.1)
`,
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
justifyContent: 'center',
gap: 8,
}}
>
{/* Folder/Sync icon */}
<svg width="48" height="48" viewBox="0 0 24 24" fill="none">
<path
d="M3 7V17C3 18.1046 3.89543 19 5 19H19C20.1046 19 21 18.1046 21 17V9C21 7.89543 20.1046 7 19 7H13L11 5H5C3.89543 5 3 5.89543 3 7Z"
stroke="rgba(255, 255, 255, 0.9)"
strokeWidth="1.5"
strokeLinecap="round"
strokeLinejoin="round"
/>
<circle
cx="12"
cy="13"
r="2.5"
stroke={colors.primaryLight}
strokeWidth="1.5"
/>
<path
d="M12 10.5V8"
stroke={colors.primaryLight}
strokeWidth="1.5"
strokeLinecap="round"
/>
</svg>
<span
style={{
color: 'rgba(255, 255, 255, 0.95)',
fontSize: '18px',
fontWeight: 600,
fontFamily: '-apple-system, BlinkMacSystemFont, sans-serif',
letterSpacing: '0.5px',
textShadow: '0 1px 2px rgba(0,0,0,0.3)',
}}
>
Source
</span>
</div>
</div>
{/* Source label */}
<div
style={{
position: 'absolute',
left: CENTER_X,
top: CENTER_Y + 100,
transform: `translateX(-50%) translateY(${labelTranslateY}px)`,
opacity: labelOpacity,
}}
>
<span
style={{
color: colors.textSecondary,
fontSize: '18px',
fontFamily: '"JetBrains Mono", monospace',
}}
>
Single Source of Truth
</span>
</div>
{/* Arrows (SVG) */}
<svg
style={{
position: 'absolute',
top: 0,
left: 0,
width: '100%',
height: '100%',
pointerEvents: 'none',
}}
>
<defs>
<linearGradient id="arrowGradient" x1="0%" y1="0%" x2="100%" y2="0%">
<stop offset="0%" stopColor={colors.primary} />
<stop offset="100%" stopColor={colors.primaryLight} />
</linearGradient>
<filter id="particleGlow" x="-50%" y="-50%" width="200%" height="200%">
<feGaussianBlur stdDeviation="3" result="coloredBlur" />
<feMerge>
<feMergeNode in="coloredBlur" />
<feMergeNode in="SourceGraphic" />
</feMerge>
</filter>
</defs>
{targetPositions.map(({ name, angle }) => {
const pos = getTargetPosition(angle);
const targetX = pos.x + 45;
const targetY = pos.y + 45;
// Animated arrow length
const currentX = CENTER_X + (targetX - CENTER_X) * arrowProgress;
const currentY = CENTER_Y + (targetY - CENTER_Y) * arrowProgress;
return (
<g key={name}>
<line
x1={CENTER_X}
y1={CENTER_Y}
x2={currentX}
y2={currentY}
stroke="url(#arrowGradient)"
strokeWidth="3"
opacity={arrowProgress > 0 ? 0.8 : 0}
/>
{/* Flowing particles along the arrow */}
{[0, 1, 2].map((particleIndex) => {
const particle = getParticlePosition(angle, particleIndex);
if (!particle) return null;
return (
<circle
key={particleIndex}
cx={particle.x}
cy={particle.y}
r={4}
fill={colors.primaryLight}
opacity={particle.opacity * 0.9}
filter="url(#particleGlow)"
/>
);
})}
</g>
);
})}
</svg>
{/* Target icons */}
{targetPositions.map(({ name, angle, delay }) => {
const pos = getTargetPosition(angle);
// Target entrance (0.4-1s, compressed)
const targetEntrance = spring({
frame: frame - 0.4 * fps - delay * 0.4,
fps,
config: { damping: 12, stiffness: 150 },
});
return (
<div
key={name}
style={{
position: 'absolute',
left: pos.x,
top: pos.y,
transform: `scale(${targetEntrance})`,
}}
>
<AIIcon name={name} size={90} enterDelay={0} showLabel={false} />
{/* Checkmark overlay */}
{checkProgress > 0 && (
<div
style={{
position: 'absolute',
top: -10,
right: -10,
width: 32,
height: 32,
borderRadius: '50%',
backgroundColor: colors.success,
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
transform: `scale(${checkProgress})`,
boxShadow: `0 0 20px ${colors.success}60`,
}}
>
<span style={{ color: '#fff', fontSize: '18px', fontWeight: 'bold' }}>✓</span>
</div>
)}
</div>
);
})}
{/* "All in sync" text */}
<div
style={{
position: 'absolute',
bottom: 80,
left: '50%',
transform: `translateX(-50%) scale(${syncTextScale})`,
opacity: syncTextOpacity,
zIndex: 100,
}}
>
<h2
style={{
fontFamily: '-apple-system, BlinkMacSystemFont, sans-serif',
fontSize: '56px',
fontWeight: 700,
color: colors.success,
margin: 0,
textShadow: `0 0 40px ${colors.success}60, 0 4px 20px rgba(0,0,0,0.5)`,
background: `linear-gradient(180deg, ${colors.success} 0%, #16a34a 100%)`,
WebkitBackgroundClip: 'text',
WebkitTextFillColor: 'transparent',
backgroundClip: 'text',
}}
>
All in sync ✓
</h2>
</div>
</AbsoluteFill>
);
};
+162
View File
@@ -0,0 +1,162 @@
import { AbsoluteFill, useCurrentFrame, useVideoConfig, spring, interpolate, Img, staticFile } from 'remotion';
import { colors } from '../styles/colors';
const FPS = 30;
export const ClosingLogo = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
// Timeline (1.5x speed):
// 0-0.3s: Fade to black
// 0.3-1.3s: Logo bounces in
// 1-1.7s: Tagline fades in
// 1.7-3s: GitHub URL fades in
// Logo entrance (1.5x speed)
const logoEntrance = spring({
frame: frame - 0.3 * fps,
fps,
config: { damping: 12, stiffness: 120 },
});
const logoScale = interpolate(logoEntrance, [0, 1], [0.5, 1]);
const logoOpacity = interpolate(logoEntrance, [0, 1], [0, 1], {
extrapolateRight: 'clamp',
});
// Glow pulse animation (stronger, more visible)
const glowCycle = (frame - 0.8 * fps) / fps;
const glowIntensity = logoEntrance > 0.5
? 40 + 80 * Math.sin(glowCycle * Math.PI * 2)
: 40;
// Tagline with spring entrance
const taglineEntrance = spring({
frame: frame - 1 * fps,
fps,
config: { damping: 15, stiffness: 120 },
});
const taglineOpacity = interpolate(taglineEntrance, [0, 1], [0, 1], {
extrapolateRight: 'clamp',
});
const taglineTranslateY = interpolate(taglineEntrance, [0, 1], [20, 0], {
extrapolateRight: 'clamp',
});
// GitHub URL with spring entrance
const urlEntrance = spring({
frame: frame - 1.7 * fps,
fps,
config: { damping: 18, stiffness: 100 },
});
const urlOpacity = interpolate(urlEntrance, [0, 1], [0, 1], {
extrapolateRight: 'clamp',
});
const urlTranslateY = interpolate(urlEntrance, [0, 1], [15, 0], {
extrapolateRight: 'clamp',
});
// Background particles (floating stars)
const particles = [
{ x: 200, y: 150, size: 3, speed: 0.02, phase: 0 },
{ x: 1700, y: 200, size: 2, speed: 0.025, phase: 1.2 },
{ x: 350, y: 800, size: 2.5, speed: 0.018, phase: 2.4 },
{ x: 1550, y: 750, size: 3, speed: 0.022, phase: 0.8 },
{ x: 960, y: 100, size: 2, speed: 0.03, phase: 1.8 },
{ x: 600, y: 300, size: 2, speed: 0.015, phase: 3.2 },
{ x: 1400, y: 450, size: 2.5, speed: 0.02, phase: 2.0 },
{ x: 300, y: 500, size: 2, speed: 0.028, phase: 0.5 },
];
const getParticleStyle = (particle: typeof particles[0]) => {
const floatPhase = frame * particle.speed + particle.phase;
const floatY = Math.sin(floatPhase) * 15;
const floatX = Math.cos(floatPhase * 0.7) * 8;
const twinkle = 0.3 + 0.7 * ((Math.sin(floatPhase * 2) + 1) / 2);
return {
position: 'absolute' as const,
left: particle.x + floatX,
top: particle.y + floatY,
width: particle.size,
height: particle.size,
borderRadius: '50%',
backgroundColor: colors.primary,
opacity: twinkle * logoOpacity,
boxShadow: `0 0 ${particle.size * 3}px ${colors.primary}60`,
};
};
return (
<AbsoluteFill
style={{
backgroundColor: colors.bgDark,
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
justifyContent: 'center',
gap: '32px',
}}
>
{/* Background floating particles */}
{particles.map((particle, i) => (
<div key={i} style={getParticleStyle(particle)} />
))}
{/* Logo */}
<div
style={{
transform: `scale(${logoScale})`,
opacity: logoOpacity,
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
gap: '24px',
}}
>
{/* Actual logo image */}
<Img
src={staticFile('logo.png')}
style={{
width: 420,
height: 'auto',
filter: `drop-shadow(0 0 ${glowIntensity}px ${colors.primary}80)`,
}}
/>
</div>
{/* Tagline */}
<p
style={{
fontFamily: '-apple-system, BlinkMacSystemFont, sans-serif',
fontSize: '36px',
fontWeight: 500,
color: colors.textPrimary,
margin: 0,
opacity: taglineOpacity,
transform: `translateY(${taglineTranslateY}px)`,
textShadow: '0 2px 10px rgba(0,0,0,0.3)',
}}
>
Edit once, sync everywhere.
</p>
{/* GitHub URL */}
<p
style={{
fontFamily: '"JetBrains Mono", monospace',
fontSize: '20px',
color: colors.primary,
margin: 0,
marginTop: '24px',
opacity: urlOpacity,
transform: `translateY(${urlTranslateY}px)`,
textShadow: `0 0 ${10 + 5 * Math.sin(frame * 0.1)}px ${colors.primary}40`,
}}
>
github.com/runkids/skillshare
</p>
</AbsoluteFill>
);
};
+198
View File
@@ -0,0 +1,198 @@
import { AbsoluteFill, useCurrentFrame, useVideoConfig, spring, interpolate, Easing } from 'remotion';
import { AIIcon, AIToolName } from '../components/AIIcon';
import { colors } from '../styles/colors';
const FPS = 30;
// Scattered positions for 4 icons (faster entrance)
const iconPositions: { name: AIToolName; x: number; y: number; delay: number }[] = [
{ name: 'claude', x: 300, y: 250, delay: 0 },
{ name: 'opencode', x: 1450, y: 220, delay: 3 },
{ name: 'codex', x: 350, y: 650, delay: 6 },
{ name: 'antigravity', x: 1400, y: 680, delay: 9 },
];
export const PainPoint = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
// Text animation: fade in at 1.3s with spring bounce
const textEntrance = spring({
frame: frame - 1.3 * fps,
fps,
config: { damping: 12, stiffness: 120 },
});
const textOpacity = interpolate(textEntrance, [0, 1], [0, 1], {
extrapolateRight: 'clamp',
});
const textScale = interpolate(textEntrance, [0, 1], [0.9, 1], {
extrapolateRight: 'clamp',
});
const textTranslateY = interpolate(textEntrance, [0, 1], [30, 0], {
extrapolateRight: 'clamp',
});
// Question mark floating animation (continuous after text appears)
const questionMarkFloat = textEntrance > 0.5 ? Math.sin((frame - 1.5 * fps) * 0.08) * 5 : 0;
// Lines animation: appear at 2.3s with drawing effect
const linesStart = 2.3 * fps;
const linesProgress = interpolate(frame, [linesStart, linesStart + 0.5 * fps], [0, 1], {
extrapolateLeft: 'clamp',
extrapolateRight: 'clamp',
easing: Easing.out(Easing.quad),
});
// Line stroke animation (for drawing effect)
const lineStrokeDashoffset = (1 - linesProgress) * 2000;
// Wobble animation for chaos effect (0.7-2.5s, extended and enhanced)
const wobblePhase = frame * 0.18;
const wobbleActive = frame >= 0.7 * fps && frame < 2.5 * fps;
const wobbleAmount = wobbleActive ? 5 : 0;
const wobbleRotation = wobbleActive ? 2 : 0;
return (
<AbsoluteFill style={{ backgroundColor: colors.bgDark }}>
{/* Scattered AI icons */}
{iconPositions.map(({ name, x, y, delay }) => {
const wobbleX = Math.sin(wobblePhase + delay) * wobbleAmount;
const wobbleY = Math.cos(wobblePhase + delay * 1.3) * wobbleAmount;
const wobbleRot = Math.sin(wobblePhase + delay * 0.7) * wobbleRotation;
const wobbleScale = wobbleActive ? 1 + 0.03 * Math.sin(wobblePhase + delay * 1.5) : 1;
return (
<div
key={name}
style={{
position: 'absolute',
left: x + wobbleX,
top: y + wobbleY,
transform: `rotate(${wobbleRot}deg) scale(${wobbleScale})`,
}}
>
<AIIcon name={name} enterDelay={delay} size={90} />
</div>
);
})}
{/* Connecting dashed lines (chaos visualization) */}
<svg
style={{
position: 'absolute',
top: 0,
left: 0,
width: '100%',
height: '100%',
pointerEvents: 'none',
}}
>
{linesProgress > 0 && (
<>
<defs>
<filter id="lineGlow" x="-20%" y="-20%" width="140%" height="140%">
<feGaussianBlur stdDeviation="2" result="coloredBlur" />
<feMerge>
<feMergeNode in="coloredBlur" />
<feMergeNode in="SourceGraphic" />
</feMerge>
</filter>
</defs>
{/* Lines that follow wobble animation */}
{(() => {
// Calculate wobble positions for each icon
const getIconCenter = (i: number) => {
const { x, y, delay } = iconPositions[i];
const wobbleX = Math.sin(wobblePhase + delay) * wobbleAmount;
const wobbleY = Math.cos(wobblePhase + delay * 1.3) * wobbleAmount;
return {
x: x + 45 + wobbleX,
y: y + 45 + wobbleY,
};
};
const p0 = getIconCenter(0);
const p1 = getIconCenter(1);
const p2 = getIconCenter(2);
const p3 = getIconCenter(3);
return (
<>
<line
x1={p0.x} y1={p0.y} x2={p1.x} y2={p1.y}
stroke={colors.error}
strokeWidth="2"
strokeDasharray="10,10"
strokeDashoffset={lineStrokeDashoffset * 0.8}
opacity={linesProgress * 0.7}
filter="url(#lineGlow)"
/>
<line
x1={p1.x} y1={p1.y} x2={p3.x} y2={p3.y}
stroke={colors.error}
strokeWidth="2"
strokeDasharray="10,10"
strokeDashoffset={lineStrokeDashoffset * 0.9}
opacity={linesProgress * 0.7}
filter="url(#lineGlow)"
/>
<line
x1={p2.x} y1={p2.y} x2={p3.x} y2={p3.y}
stroke={colors.error}
strokeWidth="2"
strokeDasharray="10,10"
strokeDashoffset={lineStrokeDashoffset}
opacity={linesProgress * 0.7}
filter="url(#lineGlow)"
/>
<line
x1={p0.x} y1={p0.y} x2={p2.x} y2={p2.y}
stroke={colors.error}
strokeWidth="2"
strokeDasharray="10,10"
strokeDashoffset={lineStrokeDashoffset * 1.1}
opacity={linesProgress * 0.7}
filter="url(#lineGlow)"
/>
</>
);
})()}
</>
)}
</svg>
{/* Main text */}
<div
style={{
position: 'absolute',
top: '50%',
left: '50%',
transform: `translate(-50%, -50%) translateY(${textTranslateY}px) scale(${textScale})`,
opacity: textOpacity,
}}
>
<h1
style={{
fontFamily: '-apple-system, BlinkMacSystemFont, sans-serif',
fontSize: '64px',
fontWeight: 600,
color: colors.textPrimary,
textAlign: 'center',
margin: 0,
textShadow: '0 4px 20px rgba(0, 0, 0, 0.5)',
}}
>
Skills scattered everywhere
<span
style={{
display: 'inline-block',
transform: `translateY(${questionMarkFloat}px)`,
color: colors.error,
}}
>
?
</span>
</h1>
</div>
</AbsoluteFill>
);
};
+358
View File
@@ -0,0 +1,358 @@
import { AbsoluteFill, useCurrentFrame, useVideoConfig, spring, interpolate } from 'remotion';
import { MacTerminal } from '../components/MacTerminal';
import { Typewriter } from '../components/Typewriter';
import { colors } from '../styles/colors';
const FPS = 30;
export const TeamFeature = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
// Timeline (1.5x speed):
// 0-0.3s: Title flies in
// 0.3-0.7s: Terminal + Team visual appear
// 0.7-2.3s: Typewriter animation
// 2.3-2.7s: Hold
// Main title entrance
const titleEntrance = spring({
frame,
fps,
config: { damping: 12, stiffness: 150 },
});
// Content entrance
const contentEntrance = spring({
frame: frame - 0.25 * fps,
fps,
config: { damping: 15 },
});
// Connection pulse animation
const pulsePhase = (frame % 30) / 30;
const pulseOpacity = 0.3 + 0.4 * Math.sin(pulsePhase * Math.PI * 2);
const command = 'skillshare install team/skills --track';
return (
<AbsoluteFill
style={{
backgroundColor: colors.bgDark,
}}
>
{/* Glowing background effect */}
<div
style={{
position: 'absolute',
top: '50%',
left: '50%',
transform: 'translate(-50%, -50%)',
width: 800,
height: 800,
borderRadius: '50%',
background: `radial-gradient(circle, ${colors.primary}15 0%, transparent 70%)`,
opacity: pulseOpacity,
}}
/>
{/* Main title - top */}
<div
style={{
position: 'absolute',
top: 80,
left: '50%',
transform: `translateX(-50%) scale(${titleEntrance}) translateY(${(1 - titleEntrance) * -30}px)`,
}}
>
<h1
style={{
fontFamily: '-apple-system, BlinkMacSystemFont, sans-serif',
fontSize: '72px',
fontWeight: 700,
color: colors.textPrimary,
margin: 0,
textShadow: `0 0 60px ${colors.primary}60`,
}}
>
Team Edition
</h1>
</div>
{/* Content container - centered layout */}
<div
style={{
position: 'absolute',
top: '50%',
left: '50%',
transform: `translate(-50%, -50%) scale(${contentEntrance})`,
opacity: contentEntrance,
display: 'flex',
alignItems: 'center',
gap: '60px',
}}
>
{/* Left: Terminal with typewriter */}
<MacTerminal title="Terminal" width={680} enterDelay={0}>
<Typewriter
text={command}
startFrame={0.5 * fps}
speed={1}
showCursor={true}
/>
</MacTerminal>
{/* Right: Team visualization - enlarged */}
<div
style={{
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
gap: '24px',
position: 'relative',
minWidth: 320,
}}
>
{/* Source node with pulse - Glassmorphism style */}
<div style={{ position: 'relative' }}>
{/* Pulse ring */}
<PulseRing />
{/* Glow layer */}
<div
style={{
position: 'absolute',
inset: -15,
borderRadius: '50%',
background: `radial-gradient(circle, ${colors.primary}40 0%, transparent 70%)`,
filter: 'blur(12px)',
zIndex: 1,
}}
/>
{/* Glass card */}
<div
style={{
position: 'relative',
width: 110,
height: 110,
borderRadius: '24px',
background: `linear-gradient(135deg, rgba(99, 102, 241, 0.25) 0%, rgba(99, 102, 241, 0.1) 100%)`,
backdropFilter: 'blur(16px)',
WebkitBackdropFilter: 'blur(16px)',
border: '1px solid rgba(255, 255, 255, 0.18)',
boxShadow: `
0 8px 32px rgba(0, 0, 0, 0.3),
0 0 30px ${colors.primary}30,
inset 0 1px 0 rgba(255, 255, 255, 0.1)
`,
display: 'flex',
flexDirection: 'column',
alignItems: 'center',
justifyContent: 'center',
gap: 6,
zIndex: 2,
}}
>
{/* Folder icon */}
<svg width="36" height="36" viewBox="0 0 24 24" fill="none">
<path
d="M3 7V17C3 18.1046 3.89543 19 5 19H19C20.1046 19 21 18.1046 21 17V9C21 7.89543 20.1046 7 19 7H13L11 5H5C3.89543 5 3 5.89543 3 7Z"
stroke="rgba(255, 255, 255, 0.9)"
strokeWidth="1.5"
strokeLinecap="round"
strokeLinejoin="round"
/>
</svg>
<span
style={{
color: 'rgba(255, 255, 255, 0.95)',
fontSize: '14px',
fontWeight: 600,
fontFamily: '-apple-system, sans-serif',
textShadow: '0 1px 2px rgba(0,0,0,0.3)',
}}
>
Source
</span>
</div>
</div>
{/* Connection lines with animated particles */}
<svg width="220" height="50" style={{ overflow: 'visible' }}>
<defs>
<linearGradient id="lineGradient" x1="0%" y1="0%" x2="0%" y2="100%">
<stop offset="0%" stopColor={colors.primary} stopOpacity="0.8" />
<stop offset="100%" stopColor={colors.primaryLight} stopOpacity="0.4" />
</linearGradient>
</defs>
{/* Lines */}
<line x1="110" y1="0" x2="30" y2="50" stroke="url(#lineGradient)" strokeWidth="2.5" />
<line x1="110" y1="0" x2="110" y2="50" stroke="url(#lineGradient)" strokeWidth="2.5" />
<line x1="110" y1="0" x2="190" y2="50" stroke="url(#lineGradient)" strokeWidth="2.5" />
{/* Animated particles */}
<SyncParticle startX={110} startY={0} endX={30} endY={50} delay={0} />
<SyncParticle startX={110} startY={0} endX={110} endY={50} delay={8} />
<SyncParticle startX={110} startY={0} endX={190} endY={50} delay={16} />
</svg>
{/* Team members with sync animation */}
<div style={{ display: 'flex', gap: '24px' }}>
{[0, 1, 2].map((i) => (
<TeamMember key={i} index={i} />
))}
</div>
{/* Label */}
<span
style={{
color: colors.textPrimary,
fontSize: '22px',
fontWeight: 600,
fontFamily: '-apple-system, sans-serif',
marginTop: '8px',
}}
>
Share with your team
</span>
</div>
</div>
</AbsoluteFill>
);
};
// Pulse ring animation around source
const PulseRing = () => {
const frame = useCurrentFrame();
// Repeating pulse every 45 frames
const cycleFrame = frame % 45;
const pulseProgress = interpolate(cycleFrame, [0, 45], [0, 1]);
const scale = interpolate(pulseProgress, [0, 1], [1, 1.8]);
const opacity = interpolate(pulseProgress, [0, 0.5, 1], [0.5, 0.25, 0]);
return (
<div
style={{
position: 'absolute',
top: '50%',
left: '50%',
width: 110,
height: 110,
borderRadius: '24px',
border: `2px solid ${colors.primary}`,
transform: `translate(-50%, -50%) scale(${scale})`,
opacity,
zIndex: 0,
}}
/>
);
};
// Animated sync particle
const SyncParticle = ({
startX,
startY,
endX,
endY,
delay,
}: {
startX: number;
startY: number;
endX: number;
endY: number;
delay: number;
}) => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
// Start animation after typing starts (1.5x speed)
const animStart = 1 * fps + delay;
const cycleDuration = 30;
const cycleFrame = Math.max(0, (frame - animStart) % cycleDuration);
const progress = interpolate(cycleFrame, [0, cycleDuration], [0, 1]);
const x = interpolate(progress, [0, 1], [startX, endX]);
const y = interpolate(progress, [0, 1], [startY, endY]);
const opacity = frame >= animStart ? interpolate(progress, [0, 0.5, 1], [0, 1, 0]) : 0;
return (
<circle
cx={x}
cy={y}
r="5"
fill={colors.primaryLight}
opacity={opacity}
style={{ filter: `drop-shadow(0 0 8px ${colors.primary})` }}
/>
);
};
// Team member avatar component with sync checkmark - enlarged
const TeamMember = ({ index }: { index: number }) => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
const entrance = spring({
frame: frame - 0.6 * fps - index * 4,
fps,
config: { damping: 12 },
});
// Checkmark appears after sync particle reaches (1.5x speed)
const checkDelay = 1.5 * fps + index * 7;
const checkProgress = spring({
frame: frame - checkDelay,
fps,
config: { damping: 10, stiffness: 180 }, // Bouncy checkmark
});
return (
<div style={{ position: 'relative' }}>
<div
style={{
width: 72,
height: 72,
borderRadius: '50%',
backgroundColor: colors.textSecondary,
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
transform: `scale(${entrance})`,
boxShadow: '0 6px 20px rgba(0,0,0,0.35)',
}}
>
<svg width="36" height="36" viewBox="0 0 24 24" fill="none">
<circle cx="12" cy="8" r="4" fill={colors.bgDark} />
<path
d="M4 20c0-4 4-6 8-6s8 2 8 6"
stroke={colors.bgDark}
strokeWidth="2.5"
strokeLinecap="round"
/>
</svg>
</div>
{/* Checkmark badge */}
{checkProgress > 0 && (
<div
style={{
position: 'absolute',
top: -4,
right: -4,
width: 28,
height: 28,
borderRadius: '50%',
backgroundColor: colors.success,
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
transform: `scale(${checkProgress})`,
boxShadow: `0 0 16px ${colors.success}60`,
}}
>
<span style={{ color: '#fff', fontSize: '16px', fontWeight: 'bold' }}>✓</span>
</div>
)}
</div>
);
};
+167
View File
@@ -0,0 +1,167 @@
import { AbsoluteFill, useCurrentFrame, useVideoConfig, spring, interpolate } from 'remotion';
import { MacTerminal } from '../components/MacTerminal';
import { Typewriter } from '../components/Typewriter';
import { Cursor } from '../components/Cursor';
import { colors } from '../styles/colors';
const FPS = 30;
// Output lines for init command (updated tool names)
const initOutputLines = [
{ text: '✓ Detected: claude, opencode, codex, antigravity', color: colors.terminalGreen },
{ text: '✓ Created ~/.config/skillshare/skills', color: colors.terminalGreen },
{ text: '✓ Ready to sync', color: colors.terminalGreen },
];
// Output for sync command
const syncOutputLine = { text: '✓ Synced 5 skills to 4 targets', color: colors.terminalGreen };
export const TerminalDemo = () => {
const frame = useCurrentFrame();
const { fps } = useVideoConfig();
// Timeline (1.5x speed):
// 0-0.7s: Terminal enters
// 0.7-1.8s: Type "skillshare init"
// 1.8-2.7s: Show init output
// 2.7-4s: Type "skillshare sync"
// 4-5.3s: Show sync output
const initCommand = 'skillshare init';
const syncCommand = 'skillshare sync';
// Command typing timings (1.5x speed)
const initTypeStart = 0.7 * fps;
const initTypeDuration = initCommand.length * 1.2; // 1.2 frames per char
const initOutputStart = initTypeStart + initTypeDuration + 8;
const syncTypeStart = 2.7 * fps;
const syncTypeDuration = syncCommand.length * 1.2;
const syncOutputStart = syncTypeStart + syncTypeDuration + 8;
// Calculate which output lines to show
const showInitOutput = frame >= initOutputStart;
const showSyncOutput = frame >= syncOutputStart;
// Output line stagger animation with slide-in effect
const getLineAnimation = (lineIndex: number, outputStart: number) => {
const lineDelay = lineIndex * 5; // 5 frames between each line
const lineFrame = frame - outputStart - lineDelay;
if (lineFrame < 0) return { opacity: 0, transform: 'translateX(-20px)', scale: 0.95 };
const progress = spring({
frame: lineFrame,
fps,
config: { damping: 15, stiffness: 200 },
});
const opacity = interpolate(progress, [0, 1], [0, 1], {
extrapolateRight: 'clamp',
});
const translateX = interpolate(progress, [0, 1], [-20, 0], {
extrapolateRight: 'clamp',
});
const scale = interpolate(progress, [0, 1], [0.95, 1], {
extrapolateRight: 'clamp',
});
return { opacity, transform: `translateX(${translateX}px)`, scale };
};
return (
<AbsoluteFill
style={{
backgroundColor: colors.bgDark,
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
}}
>
<MacTerminal title="skillshare — Terminal" width={1100} enterDelay={0}>
<div style={{ display: 'flex', flexDirection: 'column', gap: '8px' }}>
{/* Init command */}
<Typewriter
text={initCommand}
startFrame={initTypeStart}
speed={2}
showCursor={!showInitOutput && frame >= initTypeStart}
/>
{/* Init output */}
{showInitOutput && (
<div style={{ marginTop: '8px', marginBottom: '16px' }}>
{initOutputLines.map((line, i) => {
const anim = getLineAnimation(i, initOutputStart);
return (
<div
key={i}
style={{
fontFamily: '"JetBrains Mono", monospace',
fontSize: '20px',
color: line.color,
opacity: anim.opacity,
transform: `${anim.transform} scale(${anim.scale})`,
marginBottom: '4px',
transformOrigin: 'left center',
}}
>
{line.text}
</div>
);
})}
</div>
)}
{/* Sync command */}
{frame >= syncTypeStart - 10 && (
<Typewriter
text={syncCommand}
startFrame={syncTypeStart}
speed={2}
showCursor={!showSyncOutput && frame >= syncTypeStart}
/>
)}
{/* Sync output */}
{showSyncOutput && (() => {
const anim = getLineAnimation(0, syncOutputStart);
return (
<div
style={{
fontFamily: '"JetBrains Mono", monospace',
fontSize: '20px',
color: syncOutputLine.color,
opacity: anim.opacity,
transform: `${anim.transform} scale(${anim.scale})`,
marginTop: '8px',
transformOrigin: 'left center',
}}
>
{syncOutputLine.text}
</div>
);
})()}
{/* Final cursor */}
{showSyncOutput && frame >= syncOutputStart + 15 && (
<div style={{ marginTop: '8px' }}>
<span
style={{
fontFamily: '"JetBrains Mono", monospace',
fontSize: '24px',
color: colors.terminalGreen,
}}
>
${' '}
</span>
<Cursor />
</div>
)}
</div>
</MacTerminal>
</AbsoluteFill>
);
};
+38
View File
@@ -0,0 +1,38 @@
// Color palette for skillshare promo video
export const colors = {
// Background
bgDark: '#0f0f0f',
bgTerminal: '#f5f5f5',
// Brand
primary: '#6366f1', // Purple-blue for skillshare
primaryLight: '#818cf8',
// Status
success: '#22c55e',
error: '#ef4444',
warning: '#f59e0b',
// Text
textPrimary: '#ffffff',
textSecondary: '#a1a1aa',
textDark: '#18181b',
// Terminal
terminalBg: '#ffffff',
terminalText: '#1e1e1e',
terminalGreen: '#16a34a',
// Traffic lights
trafficRed: '#ff5f57',
trafficYellow: '#febc2e',
trafficGreen: '#28c840',
// AI CLI brand colors (approximate)
claude: '#d97706',
cursor: '#000000',
codex: '#10a37f',
gemini: '#4285f4',
windsurf: '#06b6d4',
};
+19
View File
@@ -0,0 +1,19 @@
{
"compilerOptions": {
"target": "ES2020",
"module": "ESNext",
"lib": ["DOM", "DOM.Iterable", "ESNext"],
"jsx": "react-jsx",
"strict": true,
"moduleResolution": "bundler",
"allowImportingTsExtensions": true,
"noEmit": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true,
"resolveJsonModule": true,
"isolatedModules": true
},
"include": ["src/**/*"],
"exclude": ["node_modules"]
}