Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import { writeText } from "@tauri-apps/plugin-clipboard-manager";
import {
createEffect,
createMemo,
createSignal,
on,
onCleanup,
Show,
} from "solid-js";
import toast from "solid-toast";
import { useEditorContext } from "./context";
type PerformanceOverlayProps = {
size: { width: number; height: number };
};
type FrameStats = {
fps: number;
avgFrameMs: number;
minFrameMs: number;
maxFrameMs: number;
jitter: number;
droppedFrames: number;
totalFrames: number;
};
const STATS_WINDOW_MS = 1000;
const MAX_TIMESTAMPS = 120;
export function PerformanceOverlay(_props: PerformanceOverlayProps) {
const { performanceMode, latestFrame, editorState } = useEditorContext();
let frameTimestamps: number[] = [];
let lastFrameTime = 0;
let frameIntervals: number[] = [];
let droppedFrameCount = 0;
let totalFrameCount = 0;
const [stats, setStats] = createSignal<FrameStats>({
fps: 0,
avgFrameMs: 0,
minFrameMs: 0,
maxFrameMs: 0,
jitter: 0,
droppedFrames: 0,
totalFrames: 0,
});
const calculateStats = (): FrameStats => {
const now = performance.now();
while (
frameTimestamps.length > 0 &&
now - frameTimestamps[0] > STATS_WINDOW_MS
) {
frameTimestamps.shift();
}
while (frameIntervals.length > MAX_TIMESTAMPS) {
frameIntervals.shift();
}
if (frameTimestamps.length < 2) {
return {
fps: 0,
avgFrameMs: 0,
minFrameMs: 0,
maxFrameMs: 0,
jitter: 0,
droppedFrames: droppedFrameCount,
totalFrames: totalFrameCount,
};
}
const windowMs = now - frameTimestamps[0];
const fps =
windowMs > 0 ? ((frameTimestamps.length - 1) / windowMs) * 1000 : 0;
let avgFrameMs = 0;
let minFrameMs = Number.MAX_VALUE;
let maxFrameMs = 0;
if (frameIntervals.length > 0) {
let sum = 0;
for (const interval of frameIntervals) {
sum += interval;
minFrameMs = Math.min(minFrameMs, interval);
maxFrameMs = Math.max(maxFrameMs, interval);
}
avgFrameMs = sum / frameIntervals.length;
}
let jitter = 0;
if (frameIntervals.length > 1) {
let varianceSum = 0;
for (const interval of frameIntervals) {
varianceSum += (interval - avgFrameMs) ** 2;
}
jitter = Math.sqrt(varianceSum / frameIntervals.length);
}
return {
fps,
avgFrameMs,
minFrameMs: minFrameMs === Number.MAX_VALUE ? 0 : minFrameMs,
maxFrameMs,
jitter,
droppedFrames: droppedFrameCount,
totalFrames: totalFrameCount,
};
};
createEffect(
on(
() => latestFrame(),
() => {
if (!performanceMode()) return;
const now = performance.now();
totalFrameCount++;
if (lastFrameTime > 0) {
const interval = now - lastFrameTime;
frameIntervals.push(interval);
frameTimestamps.push(now);
const expectedInterval = 1000 / 60;
if (interval > expectedInterval * 1.8) {
const missedFrames = Math.floor(interval / expectedInterval) - 1;
droppedFrameCount += missedFrames;
}
} else {
frameTimestamps.push(now);
}
lastFrameTime = now;
setStats(calculateStats());
},
),
);
const resetStats = () => {
frameTimestamps = [];
frameIntervals = [];
lastFrameTime = 0;
droppedFrameCount = 0;
totalFrameCount = 0;
setStats({
fps: 0,
avgFrameMs: 0,
minFrameMs: 0,
maxFrameMs: 0,
jitter: 0,
droppedFrames: 0,
totalFrames: 0,
});
};
createEffect(() => {
if (!performanceMode()) {
resetStats();
}
});
onCleanup(() => {
resetStats();
});
const formatFps = (fps: number) => fps.toFixed(1);
const formatMs = (ms: number) => ms.toFixed(2);
const copyStatsToClipboard = async () => {
const s = stats();
const statsText = [
`FPS: ${formatFps(s.fps)}`,
`Frame: ${formatMs(s.avgFrameMs)}ms avg`,
`Range: ${formatMs(s.minFrameMs)} - ${formatMs(s.maxFrameMs)}ms`,
`Jitter: ±${formatMs(s.jitter)}ms`,
s.droppedFrames > 0
? `Dropped: ${s.droppedFrames}/${s.totalFrames}`
: null,
`Playing: ${editorState.playing ? "Yes" : "No"}`,
]
.filter(Boolean)
.join("\n");
await writeText(statsText);
toast.success("Performance stats copied to clipboard");
};
const fpsColor = createMemo(() => {
const fps = stats().fps;
if (fps >= 55) return "#4ade80";
if (fps >= 45) return "#a3e635";
if (fps >= 30) return "#fbbf24";
if (fps >= 15) return "#fb923c";
return "#f87171";
});
const jitterColor = createMemo(() => {
const jitter = stats().jitter;
if (jitter < 2) return "#4ade80";
if (jitter < 5) return "#a3e635";
if (jitter < 10) return "#fbbf24";
return "#f87171";
});
return (
<Show when={performanceMode()}>
<div
class="absolute top-2 left-2 z-50 pointer-events-none select-none"
style={{
"font-family":
"ui-monospace, 'SF Mono', Monaco, 'Cascadia Mono', 'Segoe UI Mono', 'Roboto Mono', Menlo, monospace",
"font-size": "10px",
"line-height": "1.4",
"font-variant-numeric": "tabular-nums",
}}
>
<div
class="rounded-md px-2 py-1.5 shadow-lg backdrop-blur-xs pointer-events-auto hover:brightness-110 transition-[filter]"
style={{
"background-color": "rgba(0, 0, 0, 0.8)",
border: "1px solid rgba(255, 255, 255, 0.15)",
}}
onClick={copyStatsToClipboard}
title="Click to copy stats"
>
<div class="flex flex-col gap-0.5">
<div class="flex items-center gap-2">
<span class="font-bold" style={{ color: fpsColor() }}>
{formatFps(stats().fps)} FPS
</span>
<Show when={editorState.playing}>
<span style={{ color: "#4ade80" }}>▶</span>
</Show>
</div>
<div style={{ color: "rgba(255, 255, 255, 0.7)" }}>
<span>Frame: </span>
<span style={{ color: "#93c5fd" }}>
{formatMs(stats().avgFrameMs)}ms
</span>
<span style={{ color: "rgba(255, 255, 255, 0.4)" }}> avg</span>
</div>
<div style={{ color: "rgba(255, 255, 255, 0.7)" }}>
<span>Range: </span>
<span style={{ color: "#86efac" }}>
{formatMs(stats().minFrameMs)}
</span>
<span style={{ color: "rgba(255, 255, 255, 0.3)" }}> - </span>
<span style={{ color: "#fca5a5" }}>
{formatMs(stats().maxFrameMs)}ms
</span>
</div>
<div style={{ color: "rgba(255, 255, 255, 0.7)" }}>
<span>Jitter: </span>
<span style={{ color: jitterColor() }}>
±{formatMs(stats().jitter)}ms
</span>
</div>
<Show when={stats().droppedFrames > 0}>
<div style={{ color: "#f87171" }}>
Dropped: {stats().droppedFrames}/{stats().totalFrames}
</div>
</Show>
</div>
</div>
</div>
</Show>
);
}