Prompts
Featured
Models
Submit
Blog

AhaPrompt

AI Prompts for Images, Video & Audio — Every Model, One Library

Explore

All Prompts
Featured Prompts
Image Prompts
Video Prompts
Audio Prompts
AI Models
Submit a Prompt
Blog

Languages

English
中文
日本語
한국어

Copyright © 2026 AhaPrompt All rights reserved.

Privacy Policy Terms of Service

HomeAI Prompt LibraryAI Video PromptsTransforming Sports Car Robot X-Ray Model

Transforming Sports Car Robot X-Ray Model

GPT-6 AstraOpenAIvideo

Build a detailed sports car that transforms into a humanoid robot, with an x-ray mode and interactive exploded view

Details

Type: AI Video Prompts
Aspect Ratio: 720:661
Duration: 1:01
Updated: Sep 29, 2026

Category

Sci-Fi 3D Render Vehicles

How to use this prompt

1Copy the full prompt with the copy button above.
2Open GPT-6 Astra by OpenAI, or your preferred AI video generator.
3Paste the prompt and keep the camera and motion terms — they steer the cinematography.
4Match the example's settings (720:661 · 1:01 · Sci-Fi · 3D Render · Vehicles), then iterate — small wording changes shift the output a lot.

Frequently asked questions

Which AI model generated this video?

This clip was generated with GPT-6 Astra by OpenAI. The prompt on this page is the exact text used to create it.

What settings does this prompt use?

The example was generated with GPT-6 Astra using: 720:661 · 1:01 · Sci-Fi · 3D Render · Vehicles. Reusing these settings gives the closest match.

How do I get similar results?

Copy the prompt as-is first, then change the subject while keeping the camera, motion, and lighting terms. Video models are sensitive to wording, so expect a few runs.

Can I modify this prompt?

Yes. Prompts work best as starting points — swap scenes, adjust pacing terms, or change the aspect ratio to fit your project.

More GPT-6 Astra prompts

You are the founder, GPT-6 Astra is the operator, and every function of the company becomes a node with an owner, an output and a check. Seven layers do the work: > Functions -> nodes, edges, parallel work. > Agents -> one subagent per node, only the context it needs. > Code nodes -> anything with one correct answer runs as code. > Permissions, gates, return paths, weekly review. The founder approves money, hiring and anything public. Everything else runs in the loop and lands in company.md, checks.md and progress.md

We have connected a third-person camera and a Wuji2 robotic hand for control. Please control the robotic hand to move itself into an upright configuration, with its base positioned at the bottom, rather than lying flat as it is now. You need to figure out on your own how to adjust the robotic hand pose to achieve this. Please record a video while operating.

You are given a task to integrate an existing React component in the codebase The codebase should support: - shadcn project structure - Tailwind CSS - Typescript If it doesn't, provide instructions on how to setup project via shadcn CLI, install Tailwind or Typescript. Determine the default path for components and styles. If default path for components is not /components/ui, provide instructions on why it's important to create this folder Copy-paste this component to /components/ui folder: ```tsx mac-book-neo-hero.tsx "use client"; import * as React from "react"; import { useEffect, useRef, useState } from "react"; export type FrameSequenceStep = { from: number; to: number; color: string; num: string; total: string; icon?: React.ReactNode; title: string; description: string; label: string; }; export type FrameSequenceHeroProps = { frameCount: number; framePath: (i: number) => string; eagerCount?: number; scrollHeight?: string; brand?: React.ReactNode; navLinks?: { label: string; href: string }[]; ctaLabel?: string; ctaHref?: string; title: React.ReactNode; subtitle?: string; steps: FrameSequenceStep[]; className?: string; }; const cx = (...c: (string | false | null | undefined)[]) => c.filter(Boolean).join(" "); export function FrameSequenceHero({ frameCount, framePath, eagerCount = 140, scrollHeight = "600vh", brand, navLinks = [], ctaLabel, ctaHref = "#", title, subtitle, steps, className, }: FrameSequenceHeroProps) { const spacerRef = useRef(null); const cacheRef = useRef(new Array(frameCount)); const loadedRef = useRef(0); const targetFrameRef = useRef(0); const displayFrameRef = useRef(0); const lastShownRef = useRef(-1); const rafActiveRef = useRef(false); const [loadPct, setLoadPct] = useState(0); const [loaderDone, setLoaderDone] = useState(false); const [navScrolled, setNavScrolled] = useState(false); const [subHidden, setSubHidden] = useState(false); const [activeIdx, setActiveIdx] = useState(-1); const [progress, setProgress] = useState(0); const [stepLocal, setStepLocal] = useState(0); const [currentSrc, setCurrentSrc] = useState(() => framePath(1)); const showFrame = (i: number) => { if (i === lastShownRef.current) return; setCurrentSrc(framePath(i + 1)); lastShownRef.current = i; }; const loop = () => { if (rafActiveRef.current) return; rafActiveRef.current = true; const tick = () => { const diff = targetFrameRef.current - displayFrameRef.current; if (Math.abs(diff) { const eager = Math.min(eagerCount, frameCount); const loadOne = (i: number) => { const img = new Image(); img.decoding = "async"; img.src = framePath(i + 1); const onSettle = () => { loadedRef.current += 1; const pct = Math.round((loadedRef.current / frameCount) * 100); setLoadPct(pct); if (loadedRef.current === eager) { setLoaderDone(true); for (let j = eager; j { const spacer = spacerRef.current; if (!spacer) return; const total = spacer.offsetHeight - window.innerHeight; const p = Math.max(0, Math.min(1, window.scrollY / Math.max(1, total))); targetFrameRef.current = p * (frameCount - 1); loop(); setProgress(p); setNavScrolled(window.scrollY > 4); setSubHidden(window.scrollY > 8); let idx = -1; let local = 0; for (let i = 0; i = s.from && p { window.addEventListener("scroll", onScroll, { passive: true }); window.addEventListener("resize", onScroll); onScroll(); return () => { window.removeEventListener("scroll", onScroll); window.removeEventListener("resize", onScroll); }; // eslint-disable-next-line react-hooks/exhaustive-deps }, [steps, frameCount]); return ( {loadPct {brand} {navLinks.length > 0 && ( {https://t.co/tSkQpsSthN((l) => ( {l.label} ))} )}

Create game ready 3d fully rigged honor harrington most advanced spaceship from the book series called "honor harrington" When done with main model create combat scene where main model fights 3 hostile ships

Create a complete, polished motion graphics video called “SIGNAL — Turn ideas into motion” Generate a 20-second motion graphics video at 1920×1080 and 120 FPS. Create the entire animation procedurally in Python. Include the complete editable Python source file. Build the animation, render every frame, inspect the output, and export the finished MP4. Do not stop at a storyboard, mockup, explanation, or individual frames. The final result must be a fully rendered motion graphics video. No external visual assets are necessary. Generate all typography, shapes, backgrounds, grids, lines, cards, transitions, and visual effects directly through code. Create a premium futuristic motion identity for a fictional creative technology company called SIGNAL. The visual language should feel like a combination of modern product design, editorial typography, Swiss graphic design, and high-end technology branding. Palette: Near-black: #111214 Warm white: #F4F1E8 Electric lime: #C7FF45 Soft gray: #A7AAA5 Use a clean geometric sans-serif font such as Geist, Inter, Helvetica, or a comparable system font. Typography should be large, confident, and tightly composed. Use generous negative space. Maintain consistent margins and alignment throughout the animation. Avoid unnecessary decoration. Every scene should have one dominant visual idea. The central visual motif is a SIGNAL LINE. The line begins as a tiny pulse. It expands into a waveform. The waveform becomes a grid. The grid becomes cards. The cards collapse into a single line. That line eventually constructs the SIGNAL wordmark. Every transformation should visibly originate from the previous object. Nothing should feel like an unrelated scene replacement. Motion should feel precise, fluid, mechanical, and slightly weighted. Fast transformations should always resolve into readable compositions. 0–2 seconds: Begin with a near-black background. Place a tiny electric-lime horizontal line in the exact center. The line should initially appear almost motionless. A subtle pulse travels through it. As the pulse reaches the center, the line expands horizontally. Reveal large warm-white typography: “IDEAS” Then underneath: “NEED SIGNAL.” Keep the typography left aligned. Small supporting text: “Turn noise into something worth noticing.” The lime signal line remains visible on the right side of the composition. Allow approximately one second of readable hold. 2–4 seconds: The signal line begins oscillating. Transform it smoothly into a clean waveform. The waveform should react rhythmically rather than randomly. Introduce several thin gray guide lines behind it. The waveform stretches across most of the screen. Large typography changes to: “FIND THE PATTERN” Small supporting copy: “Every idea starts as noise.” Animate individual waveform peaks with slight timing offsets. Keep movement controlled. Do not create chaotic audio-visualizer movement. 4–6 seconds: Freeze the waveform momentarily. Extend vertical lines downward from selected waveform peaks. Extend horizontal lines outward. These lines gradually construct a modular grid. The waveform itself should become one of the grid's horizontal lines. Do not remove it and introduce a new grid separately. Once the grid is established, reveal small labels inside several cells: “IDEA” “BUILD” “TEST” “BREAK” “LEARN” “SHIP” Highlight one cell in electric lime. Headline: “STRUCTURE THE NOISE” Hold long enough for the composition to remain readable. 6–9 seconds: Selected grid cells detach from the grid. They become floating rectangular cards. Each card should preserve its original dimensions and position during the beginning of the transformation. Then allow the cards to reorganize around the center. Use approximately six cards. Cards should have restrained shadows and minimal depth. Most cards should be warm white. One card should remain electric lime. Use short labels: “01 / IDEA” “02 / BUILD” “03 / TEST” “04 / REFINE” “05 / SHIP” “06 / REPEAT” The cards move into a clean horizontal sequence. Headline above: “MOVE WITH INTENT” Motion should have slight inertia while remaining controlled. No bouncing. No excessive overshoot. 9–12 seconds: Compress the cards toward the center. As they approach each other, reduce the gaps between them. The cards merge into one long horizontal strip. The strip becomes electric lime. Preserve the same horizontal axis. The strip begins bending smoothly. Transform it into a flowing continuous line that travels across the screen. Switch the background from warm white to near-black through a geometric wipe generated by the moving strip itself. Large warm-white typography appears: “MOMENTUM” Small supporting line: “ONE MOVE CREATES THE NEXT.” The signal line should travel around the typography without obscuring it. Give the line subtle depth using restrained shading. Do not use glow. Do not use neon bloom. 12–14 seconds: The moving line begins drawing geometric letterforms. First construct: S Then: I Then: G Then: N Then: A Then: L Each letter should emerge from the same continuous line. Avoid simply fading the word into existence. The viewer should clearly understand that the moving signal is physically constructing the wordmark. Once complete, display: SIGNAL Centered. Small text underneath: “TURN IDEAS INTO MOTION” Allow the composition to settle. 14–17 seconds: Collapse the SIGNAL wordmark back into the horizontal line. The transformation should reverse naturally. The line travels toward the center. Create three small pulses alon

Build a single self-contained HTML file: a 3D marble computer, in the spirit of Wintergatan's marble machine and the Digi-Comp II, that adds two 4-bit numbers using nothing but marbles falling through mechanical toggles. Hard rules: 1. One HTML file. Three.js from https://t.co/KCQbEZLusb via an import map, plus its OrbitControls addon. No other libraries, no physics engine, no external assets. 2. The mechanism is the computer. Each bit of the result is stored in a two-state toggle (flip-flop) that a marble physically flips as it passes. Carries happen because a marble leaving one toggle rolls on to the next. Do not compute the answer in JavaScript arithmetic anywhere. The displayed result must be read from the toggle states after the last marble stops. 3. Marbles move along tracks with believable gravity and timing. Nothing teleports. You may script motion along paths, but every toggle flip must be caused by a marble arriving at it. 4. Input: two rows of four switches (A and B, 0 to 15), set by clicking. A lever labelled RUN releases the marbles. A counter shows how many marbles have fallen. 5. Output: a row of five result toggles, most significant bit on the left, and a readout that shows the binary and decimal value read from those toggles. 6. A DEMO button runs 5+6, then 9+7, then 15+15, resetting between runs, so it can be screen-recorded without touching anything. 7. Looks: a wooden board, brass toggles, glass marbles, warm studio lighting, soft shadows, a slow camera that follows the busiest part of the machine. It should look good in a square 1080x1080 recording. 8. Short click sounds via the Web Audio API when a toggle flips, started only after the first user click. 9. It must run at 60 fps on a normal laptop and have no console errors. Output only the complete HTML file.

A mission-game loadout experience where you can rotate a character, switch between male and female operators, change skin tone, try different uniforms, helmets, boots and weapons, then make the character stand, walk or run.

rebuild the town as individual 3D objects, rig the bunny with a simple 20-bone skeleton, move it between two locations, and have the camera follow.

Browse all GPT-6 Astra prompts Explore AI Video Prompts