# Blender with OpenAI Astra: The Complete Guide to Creating 3D Models, Animations, Product Visuals, and Virtual Worlds

**Research and hands-on checks: September 5, 2026, Pacific time. Tutorial version: Blender 5.2.1 LTS.**

You can use OpenAI GPT-6 Astra to help build a Blender project that you can reopen, change, animate, and export. The useful result is a working 3D scene: objects with dimensions, materials you can adjust, lights you can move, and a camera you can direct.

This guide takes you from an empty project to a fictional mini PC on a studio plinth, an eight-second product shot, a furnished room tour, and a stylized spacecraft exported as GLB. The downloadable starter includes original Python code, editable Blender files, and actual preview renders. It needs no purchased assets, image generator, 3D generation service, or Blender MCP connection.

**Start with the product quickstart.** Let Astra explain or adapt the script, then run it inside Blender. Once you understand the result, a local Codex workflow can take over repetitive execution and preview inspection.

Throughout this guide, **official documentation** means a vendor’s description of supported behavior; **official demonstration** means a published example; **creator-reported** means someone’s account of their own experiment; **tested here** means an action actually executed for this article. **Proposed application** means a practical extension to try, without a claim that Astra has already demonstrated production quality in that category.

## Contents

1. [What Astra does and where Blender runs](#what-astra-does)
2. [Choose a connection route](#connection-routes)
3. [Install and organize your workspace](#setup)
4. [Your first editable product scene](#quickstart)
5. [Optional computer use and Blender MCP](#optional-connections)
6. [What you can make](#applications)
7. [Real examples and what they establish](#examples)
8. [Project A: product hero image](#project-a)
9. [Project B: eight-second animation](#project-b)
10. [Project C: furnished room tour](#project-c)
11. [Project D: spacecraft GLB](#project-d)
12. [Prompting and visual iteration](#prompting)
13. [The complete prompt library](#prompt-library)
14. [Finishing and exporting](#finishing)
15. [Troubleshooting](#troubleshooting)
16. [Kingy.ai video ideas](#video-ideas)
17. [Testing record and practical limits](#testing)
18. [Technical appendices and sources](#appendices)

<a id="what-astra-does"></a>

## 1. What Astra does and where Blender runs

GPT-6 Astra is an OpenAI model, with the model identifier `gpt-6-astra` in the current model documentation. It is separate from Google’s Project Astra, and from unrelated products using “Astra” in their names. OpenAI’s announcement describes a staged rollout; a launch announcement is not proof that every account already has access. Check the model picker on the application you intend to use. [OpenAI announcement](https://openai.com/index/gpt-6-astra/), [current model documentation](https://learn.chatgpt.com/docs/models).

There are five moving parts worth understanding:

| Part | Its job in this workflow |
|---|---|
| Astra | Interprets your brief, writes code, reasons about errors, and evaluates images supplied through available tools. |
| Host application | ChatGPT, Work, or Codex presents the conversation and determines which tools, files, and execution environments are available. |
| Blender | Stores the scene, evaluates geometry and animation, and renders images. |
| Python script | A readable set of instructions that Blender executes through its `bpy` API. |
| Optional connection | Computer-use tools or a third-party MCP bridge allow an agent to interact with an already running Blender application. |

A script is a recipe. A `.blend` file is the kitchen after the recipe has been followed: the objects exist, and you can inspect them. A PNG is a photograph of that kitchen. Each serves a different purpose, and you should keep all three.

In the local workflow used here, OpenAI processes the model interaction remotely; Blender executes on this Mac. A render does not become a cloud render simply because an AI requested it. Files and images that the host sends to the model are part of the interaction, so choose appropriate reference material and project folders.

A browser chat can provide code without having permission or a mechanism to execute it on your computer. Likewise, a hosted environment’s `/tmp` directory is not your laptop’s Downloads folder. Ask the agent to identify its execution environment before giving it file paths.

Current OpenAI documentation lists Astra support for local Codex clients and ChatGPT surfaces, while its model card marks **Codex cloud as unsupported**. Do not equate ChatGPT Work with Codex cloud: these are distinct product surfaces. [Model availability](https://learn.chatgpt.com/docs/models), [workspace boundaries](https://learn.chatgpt.com/docs/enterprise/workspace-model-availability).

### Access and billing without guesswork

1. Install or update the official desktop application from the current [OpenAI quickstart](https://learn.chatgpt.com/docs/quickstart).
2. Sign in using the ChatGPT account or workspace you intend to use.
3. Open the model controls near the composer. If the app presents simplified Power controls, open **Advanced** to inspect the specific model.
4. Select **GPT-6 Astra** when available. Confirm the selected label before starting the Blender task.
5. If it is absent, check the account, client version, rollout status, and workspace restrictions. Typing a model name in a prompt does not change the selected model.

Enterprise’s initial rollout has additional eligibility and administrator controls. The documentation says Astra is initially off by default and requires eligible organizational access before administrators enable it. API access follows a separate API organization and project. Local configuration cannot grant either entitlement. [Enterprise Astra access](https://learn.chatgpt.com/docs/enterprise/workspace-model-availability#gpt-6-astra-in-enterprise).

**You do not need an OpenAI API key for the starter.** The Python script talks only to Blender. Using Astra through a signed-in subscription consumes the allowance available in that product. API-key usage is separately billed under API pricing. ChatGPT Work and Codex share usage, and a long iterative task can consume more than a short prompt suggests. We quote no fixed per-scene AI price because context, retries, model settings, and billing route vary. [Usage and pricing](https://learn.chatgpt.com/docs/pricing).

<a id="connection-routes"></a>

## 2. Choose a connection route

The simplest beginner route has the fewest things that can fail: ask for a Blender script, read it, and run it in Blender’s Text Editor. You can complete the quickstart without installing a terminal package or connector.

| Route | Prerequisites and account | Difficulty | Automation and feedback | Costs and main limitation |
|---|---|---|---|---|
| Copy Python into Blender | Blender plus access to Astra in a supported chat surface | Beginner | You run code and share screenshots manually | Blender is free; AI allowance applies. You remain the execution and inspection link. |
| Local agent runs Blender | Blender executable; local Codex with Astra; permission to write the project and launch Blender | Intermediate setup, easy repeated use | Agent runs scripts, reads logs, opens saved previews | Local hardware renders; AI usage is separate. A remote task cannot assume your local paths exist. |
| Computer use | Supported desktop Work or Codex, Computer Use plugin, OS permissions, Astra access | Moderate | Agent operates the UI and observes screenshots | AI usage; app/region restrictions. UI state and dialogs can interrupt work. |
| Third-party Blender MCP | Local MCP-capable Codex, compatible server and Blender add-on, runtime dependencies | Advanced setup | Tool calls can inspect and modify the live scene | AI usage; optional external asset services may charge separately. Compatibility and tool scope require checking. |

The manual route is our tested use of Blender’s scripting interface and executable. OpenAI documents computer use and local STDIO MCP support separately; that does not make any community Blender bridge an official OpenAI integration. [Architecture demonstration](https://learn.chatgpt.com/blog/architectural-visualization-with-astra), [Computer Use](https://learn.chatgpt.com/docs/computer-use), [MCP](https://learn.chatgpt.com/docs/extend/mcp).

Choose local execution when you need many variations, repeatable renders, or a saved log. Choose computer use when a visual UI check is easier than reading data. Consider MCP when you want an ongoing conversation with a live Blender session. None is a prerequisite for learning the scene itself.

<a id="setup"></a>

## 3. Install and organize your workspace

### Which Blender version to use

This guide targets **Blender 5.2.1 LTS**, the installed version used for its tests. LTS means long-term support. Use the 5.2 documentation family while following the guide; the unversioned “current” API can move to a different release. A newer application may still work, but that is not the same as a tested match. [Blender downloads](https://www.blender.org/download/), [Blender 5.2 manual](https://docs.blender.org/manual/en/5.2/), [Blender 5.2 Python API](https://docs.blender.org/api/5.2/).

Before installing, check the official [system requirements](https://www.blender.org/download/requirements/) for your OS and graphics hardware. Blender 5.0 and later require Apple Silicon on macOS; an Intel Mac cannot follow this 5.2.1 tutorial unchanged. Blender identifies 4.5 LTS as the last Intel-Mac release. Do not assume a machine that runs an older Blender version supports this one.

Our practical planning advice is to start with simple geometry, small texture sets, and 960×540 previews. A recent laptop can attempt these projects without a dedicated workstation. This is a scope recommendation, not a minimum-hardware guarantee. For buying decisions, inspect actual Blender benchmarks and the scenes you plan to make.

Memory limits show up before artistic ambition does. Dense imported models, subdivision, large textures, and simulation caches can exhaust RAM or GPU memory. Keep several gigabytes free for this starter and more for rendered sequences. A 192-frame sequence averaging 3 MB per PNG would occupy roughly 576 MB, before backups; that is arithmetic for planning, not a measured size promise.

The current requirements page lists 8 GB RAM as a minimum and 32 GB as recommended. For Windows and Linux it lists a four-core SSE4.2-capable CPU and 2 GB graphics memory as baseline requirements, with additional graphics-API requirements; GPU rendering has a separate compatibility list. For macOS, it lists Apple Silicon and macOS 13 or later. The 24 GB test machine used here sits between the listed memory tiers. These are vendor requirements, not a promise about complex-scene performance.

### macOS installation

1. Download Blender from the official site and select the Apple Silicon macOS package. Intel Macs need an older supported Blender release and separately adapted instructions.
2. Open the downloaded disk image and drag **Blender** into **Applications**.
3. Launch Blender from Applications. Complete normal macOS first-launch checks.
4. In Blender, choose **Help → About Blender** and confirm the version.
5. Keep the default Blender keymap for this guide. If you use a trackpad or lack a number pad, use menu equivalents below.

For the standard app installation, the executable used here is:

```text
/Applications/Blender.app/Contents/MacOS/Blender
```

To verify it, open **Terminal**, paste this one line, and press Return:

```bash
"/Applications/Blender.app/Contents/MacOS/Blender" --version
```

This command only prints version information. You do not paste it into Blender’s Python Console.

### Windows installation

1. Download the official Windows Blender installer and run it.
2. Complete installation, then launch Blender from the Start menu.
3. Use **Help → About Blender** to check the version.
4. Locate `blender.exe` in the installation folder. A common installation path is shown below, but confirm yours in File Explorer.
5. For commands, open **PowerShell**. Its call operator `&` is needed before a quoted executable path.

```powershell
& "C:\Program Files\Blender Foundation\Blender 5.2\blender.exe" --version
```

If that path does not exist, open the Blender shortcut’s file location or inspect the installation directory. Correct the path; reinstalling Python will not repair a wrong Blender path. Windows setup instructions here were checked against documentation, not executed on Windows. [Installation chapters](https://docs.blender.org/manual/en/5.2/getting_started/installing/index.html).

### Create a project folder

Create `BlenderAstra` inside Documents, then add these folders in Finder or File Explorer:

```text
BlenderAstra/
  scenes/       editable .blend files
  scripts/      Python builders and corrections
  assets/       references and licensed textures
  previews/     small images used for decisions
  exports/      final images, frame sequences, videos, GLB
```

If you download the starter ZIP, extract it first. Keep its folder structure intact. Its ready-made `.blend` files are in `scenes`; use those immediately, or rebuild into a different empty folder to learn the process. The builder deliberately refuses to overwrite an existing `product_v001.blend` and other completed scene files.

Blender includes its own Python. For this starter, **do not install `bpy` with pip**, and do not run the builder with your ordinary system Python. Running Blender’s executable loads the application API automatically.

### Protect work without making setup complicated

Start in a new Blender file and save unrelated work first. Read generated code for unexpected downloads, subprocesses, file deletion, or credential access. Our builder uses local scene operations and writes to the folder you choose; it creates a new scene rather than deleting an existing scene.

For iterations, save `product_v002.blend` before major changes. Keep a short note describing the successful view and settings. Do not paste API keys into scripts, image captions, `.blend` text blocks, or public prompt examples. The core tutorial needs none.

<a id="quickstart"></a>

## 4. Your first editable product scene

**Goal:** a fictional titanium mini PC, a cyan status light, a warm circular plinth, a camera, three lights, a saved Blender project, and a PNG preview. No reference image is required.

Use this exact prompt with the starter script attached:

> I am learning Blender 5.2.1 LTS. Read the attached Kingy.ai build_scene.py. Explain how to run its product project in Blender’s Text Editor. Keep the fictional 140 × 100 × 45 mm enclosure, editable parts, camera, and lights. Do not add dependencies or download assets. Help me save product_v001.blend and inspect product_0001.png. If you cannot execute Blender locally, tell me the actions I must perform.

### Run the supplied script inside Blender

1. Open Blender and choose **File → New → General**, after saving any current work.
2. Select the **Scripting** workspace along the top. If it is hidden, scroll the workspace tabs or use the plus button to add a scripting workspace.
3. In the Text Editor area, choose **Text → Open** and open `scripts/build_scene.py` from the extracted starter.
4. Near the top, leave `PROJECT = 'product'` unchanged.
5. The default `ROOT` is your Documents folder followed by `BlenderAstra`. If you already have a generated scene there, change the final folder name to `BlenderAstra02`.
6. Choose **Text → Run Script**, or use the triangular Run Script control in the Text Editor.
7. Wait for Blender to finish. A render can temporarily make the interface unresponsive; do not repeatedly click Run Script.
8. Open `Documents/BlenderAstra/previews/product_0001.png` in your image viewer.
9. Choose **File → Open** in Blender and open `scenes/product_v001.blend` from that same project folder.

The saved project keeps 1920×1080 output settings. The automatic preview is rendered at 50%, so it is 960×540. Saving happens before those temporary preview changes. Reopen the saved file before following the final-render instructions.

### Know the minimum Blender vocabulary

The **viewport** is the interactive area where you orbit around the scene. It is not necessarily the image your camera will render. An **object** can be a mesh, camera, light, or other item. A **mesh** contains vertices, edges, and faces: points, connections, and surfaces.

A **collection** groups objects, like a folder. A **material** controls surface appearance. A **light** illuminates the scene. The **camera** defines the rendered viewpoint. **Transforms** are an object’s location, rotation, and scale. **Rendering** computes the final image from the scene.

The **Outliner**, usually at the upper right, lists objects and collections. In this starter, select `Astra_TestObject` to select the mini PC enclosure. Camera and light names may have suffixes such as `.001`; Blender adds those when another data block already uses the name.

### Prove that it is editable geometry

1. Select the enclosure in the Outliner.
2. Place your pointer over the 3D Viewport and press **Tab** to enter Edit Mode. You should see vertices, edges, or faces, rather than a flat image plane pretending to be a product.
3. Press **Tab** again to leave Edit Mode.
4. Press **N** over the viewport and inspect **Item → Dimensions**. The enclosure’s dimensions should be approximately 0.14 m, 0.10 m, and 0.045 m.
5. In the material controls, inspect the assigned titanium material. The cyan indicator and top panel are separate objects.
6. Use **View → Cameras → Active Camera**, or number-pad 0, to return to the render viewpoint.

The plinth and floor are intentionally larger than the product. The small front shapes suggest controls; they are not accurate representations of real ports or a functioning electronic assembly.

### Connection test and first correction

This scene is also the connection test: it creates a specifically named mesh, assigns materials, adds a camera and lights, saves a `.blend`, and renders a preview. Reopening the file completes the test. A message saying “done” without those files does not pass.

If the image is poor, attach it and use:

> Preserve the product geometry and its dimensions. Fix only framing and lighting. Keep the entire mini PC visible, show a readable cyan indicator, and prevent bright highlights from erasing the top panel. Make one 960 × 540 preview before saving a new product_v002.blend. Explain exactly which settings changed.

If the script raises an exception, copy the entire traceback, starting at “Traceback” and ending at the final error line. Include the Blender version and say whether you ran it from the Text Editor or a terminal. A screenshot of only the final word “Error” leaves out the information needed to diagnose it.

<a id="optional-connections"></a>

## 5. Optional computer use and Blender MCP

### Computer use on macOS and Windows

OpenAI’s current setup is **Plugins → Computer Use → Install/Enable**, with the server and skill toggles enabled. Review **Settings → Computer use** and the approved applications. On macOS, grant the requested Screen Recording and Accessibility permissions in **System Settings → Privacy & Security**. On Windows, keep Blender visible in the active desktop session; computer use occupies that foreground session. Availability is region- and product-dependent. [Official Computer Use instructions](https://learn.chatgpt.com/docs/computer-use).

Try a small task before a long build:

> Use Computer Use to inspect Blender. Identify the active scene and camera, then show me the mini PC in solid view and camera view. Do not change the scene. Report what you can actually see.

This is a useful separation of concerns: the builder establishes geometry, while the UI check confirms the scene is understandable in Blender. A missing permission should lead to a clear explanation, not a claim that the model saw a window it could not access.

### Three different components in an MCP connection

The community [ahujasid/blender-mcp repository](https://github.com/ahujasid/blender-mcp) describes a Blender add-on, a separate Python MCP server, and client configuration. The add-on receives commands inside Blender. The MCP process translates tool calls. Codex is the client.

The repository specifies Blender 3.0+, Python 3.10+, and `uv`; its broad minimum does not certify every function against 5.2.1. Its README contains labels from different revisions, including “Start MCP Server” and “Connect to Claude.” We checked the documented parts, but **did not install or execute this third-party integration for this guide**.

1. Install `uv` using its [official installation instructions](https://docs.astral.sh/uv/getting-started/installation/). Reopen your terminal, then verify `uv --version` and `uvx --version`.
2. In Terminal or PowerShell, run the repository’s add-on installation command:

```text
uvx blender-mcp install-addon
```

3. In Blender, open **Edit → Preferences → Add-ons** and enable **Interface: MCP for Blender**. Follow the repository’s manual installation fallback if automatic discovery fails.
4. In the 3D Viewport, press **N**, open the MCP tab, and start the add-on’s server.
5. Configure the Codex client independently, using OpenAI’s documented STDIO schema.

In the desktop client’s **Settings → MCP servers → Add server**, use a name such as `blender`, choose **STDIO**, set the command to the full path of `uvx`, and set the argument to `blender-mcp`. Save and restart the server. The CLI equivalent, **constructed from OpenAI’s documented command syntax and the repository’s server command**, is:

```bash
codex mcp add blender -- uvx blender-mcp
```

This is a documented configuration composition, not a claimed tested Astra–Blender integration. Inspect connected servers with `/mcp` in a supported local client. Hosted ChatGPT web does not read your local configuration. [OpenAI MCP configuration](https://learn.chatgpt.com/docs/extend/mcp).

If you edit `~/.codex/config.toml` manually, preserve its existing contents and append one appropriately named table:

```toml
[mcp_servers.blender]
command = "/absolute/path/to/uvx"
args = ["blender-mcp"]
```

The command path above is a placeholder: replace it with the result of `command -v uvx` on macOS/Linux, or `(Get-Command uvx).Source` in PowerShell. For Windows TOML paths, single quotes can preserve backslashes literally:

```toml
command = 'C:\Users\YOUR_NAME\.local\bin\uvx.exe'
```

Do not run multiple MCP clients against the same Blender session while diagnosing a failure. Keep the add-on connection local. Optional model-generation and asset-service features have their own accounts and licenses; enabling a bridge does not make those services free.

Finally, ask the connected agent to create one object called `Astra_MCP_Test`, give it a blue material, add a camera and area light, save a new test file, render a preview, and reopen it. Verify each result in the app and filesystem. If any part fails, use the script route while diagnosing the bridge separately.

<a id="applications"></a>

## 6. What you can make

The following map separates a possible contribution from a demonstrated result. Except where marked **Astra evidence**, treat these as proposed applications using Blender’s documented capabilities. The example prompts are original Kingy.ai prompts, not quotations from creators.

### Modeling from text and image references

**Output:** an editable approximation of an object. **Tools:** `bpy`, mesh modeling, image references. **Difficulty:** moderate for simple objects; high for exact matches.

Astra can divide a shape into parts, set dimensions, and place those parts consistently. A front photo does not reveal the back, depth, or internal structure. Provide front, side, and top views with at least one measured dimension. Ask it to mark uncertain features instead of inventing them silently.

**Prompt:** “Build a 150 mm wide desk sensor from these three views. Match the silhouette first. Keep the lens, shell, stand, and buttons separate. List dimensions inferred from perspective.”

Watch for asymmetric details, impossible thicknesses, and a convincing front view that collapses from the side. You still judge proportion and reference accuracy. **Astra evidence:** the official game case study includes concept-to-Blender asset work.

### Product visualization and hard-surface objects

**Output:** enclosures, stands, machines, and studio renders. **Tools:** primitives, bevels, modifiers, materials, cameras. **Difficulty:** beginner to intermediate.

Astra is useful for repeating vents, arranging bolts, making color variants, and setting up product shots. Small rounded edges help a hard object catch light. They are not a substitute for accurate construction.

**Prompt:** “Create a fictional palm-sized AI hub with a ceramic lid, graphite base, and one status light. Use separate named parts and a three-quarter studio camera.”

Typical failures include razor-sharp edges, giant bevels, floating buttons, and overexposed metal. You decide where detail matters at the final image size. **Tested here:** the mini PC starter.

### Architecture, interiors, and furniture

**Output:** rooms and visualization scenes. **Tools:** measured layouts, meshes, instancing, materials, camera tours. **Difficulty:** intermediate; advanced for a whole house.

Start with a floor plan and walking clearances. Add furniture only after walls, openings, and circulation make sense. A room can look excellent through one opening while containing inaccessible corners or intersecting furniture.

**Prompt:** “Create a 6 × 5 m living room with a 3 m ceiling. Show a top view before furnishing. Preserve a clear route from the entrance to the sofa.”

You review scale, usability, and visual storytelling. A visualization is not a construction document. **Astra evidence:** the official architecture case study. **Tested here:** a small open cutaway room.

### Landscapes and procedural environments

**Output:** hills, islands, stylized forests, terrain backdrops. **Tools:** mesh generation, noise, instances, Geometry Nodes. **Difficulty:** moderate.

Astra can write repeatable scattering rules and vary objects using a seed, a number controlling pseudo-random choices. It should keep heavy detail close to the camera and reuse meshes where possible.

**Prompt:** “Create a stylized island with a clear landing area, three rock shapes, and instanced trees. Use seed 42 and keep the same island outline across iterations.”

Common failures are repeated-looking trees, plants in roads, and geometry that consumes memory outside the shot. Human art direction determines believable scale and composition. This is a **proposed Blender workflow**, not evidence that an arbitrary generated world will perform well interactively.

### Geometry Nodes

**Output:** an editable procedural system with exposed controls. **Tools:** Blender’s Geometry Nodes editor and node API. **Difficulty:** intermediate to advanced.

Ask for a small graph you can understand. “Scatter panels across this surface” is more maintainable than “create an entire city in one opaque graph.” Name inputs such as Count, Seed, Spacing, and Height.

**Prompt:** “Make a Geometry Nodes setup for rows of solar panels. Expose row count, column count, spacing, tilt, and seed. Explain every node group.”

Likely failures include wrong socket names after version changes, misplaced instances, and exporting without realizing geometry. You still need to inspect the node graph and understand what its controls mean. **Proposed application.** [Geometry Nodes manual](https://docs.blender.org/manual/en/5.2/modeling/geometry_nodes/index.html).

### Materials, textures, and UV mapping

**Output:** surfaces that respond convincingly to light. **Tools:** Shader Editor, image textures, UV Editor. **Difficulty:** moderate.

UV coordinates place a 2D image on a 3D surface. Astra can help construct a material graph or automate mapping, but a wood texture with grain running the wrong way remains wrong. For a product, start with simple material values before adding textures.

**Prompt:** “Give this enclosure brushed metal with restrained roughness variation. Keep the brushing direction consistent. Show close views under a large area light.”

Watch for stretched textures, seams, incorrect image color spaces, and baked highlights mistaken for real material response. A person checks scale and finish. **Astra evidence:** material work appears in the official architectural scene; exportable texture preparation remains asset-specific.

### Lighting and cameras

**Output:** readable shots with deliberate emphasis. **Tools:** area lights, world lighting, camera lens and exposure. **Difficulty:** beginner to advanced.

Astra can propose a key light, fill, and rim, but their value comes from the visible result. A key is the main light; fill softens shadows; a rim separates the subject from the background. More lights can flatten a product rather than improve it.

**Prompt:** “Keep the camera fixed. Reduce the fill until the front and side have distinct brightness. Preserve detail on the lid and cyan indicator.”

Inspect clipped highlights, merged silhouettes, and irrelevant background emphasis. You decide what viewers should notice first. **Astra evidence and tested here.**

### Animation and motion graphics

**Output:** timed camera movement, product turns, animated parts, explainers. **Tools:** keyframes, constraints, drivers, Graph Editor. **Difficulty:** moderate.

A keyframe records a property at a chosen frame. Interpolation determines the values between keys. Astra can automate the timing, but a successful script does not prove appealing movement.

**Prompt:** “Create an eight-second shot at 24 fps. Move the camera slowly across the front of the device. Keep the indicator visible and ease the movement at both ends.”

Watch for sudden speed changes, unintended spins, camera collisions, and movement too subtle to read. You direct pacing and decide whether motion supports the message. **Tested here:** a 192-frame camera move.

### Rigging and characters

**Output:** a character controlled by a skeleton or other rig. **Tools:** armatures, constraints, skin weights, animation references. **Difficulty:** advanced.

Skin weights determine how strongly each bone moves nearby vertices. Astra may help create a rig and diagnose problems, but attractive stills cannot establish deformation quality. Test shoulders, hips, elbows, and extreme poses.

**Prompt:** “Rig this licensed low-poly robot with separate rigid limbs. Keep elbows and knees mechanically constrained. Produce a pose sheet before animating a walk.”

A rigid robot is a more manageable first target than a realistic human. Expect cleanup of weights, contacts, balance, and motion. **Creator-reported evidence** is discussed below; dependable production character work remains unproven by this guide.

### Physics and simulations

**Output:** falling objects, cloth, smoke, liquids, or other simulated motion. **Tools:** Blender simulation systems and caches. **Difficulty:** advanced.

Astra can configure a small experiment, establish scene scale, and automate a bake. A bake stores simulation results so they can be replayed. Give caches their own folder and test a short range first.

**Prompt:** “Drop three simple rigid objects onto a plane. Use meter units, explain collision margins, and bake only 48 frames before expanding.”

Failures include tunneling, exploding objects, incorrect scale, and enormous cache sizes. You still judge whether the motion is physically plausible and whether it needs an artistic adjustment. **Proposed application:** do not confuse a browser game’s water simulation with Blender fluid simulation.

### Compositing

**Output:** combined render passes, restrained glow, color adjustments, transparent overlays. **Tools:** Compositor and render passes. **Difficulty:** moderate.

Astra can arrange a basic node chain and keep it reproducible. Preserve the original render so you can compare. A noisy or poorly lit frame should not be buried under aggressive glow.

**Prompt:** “Add restrained glare to the indicator only. Keep the housing edges crisp and deliver the untouched render alongside the composited result.”

Watch for crushed shadows, halos, and color changes that misrepresent the product. You choose the final image treatment. **Proposed application.**

### Game assets

**Output:** a model a runtime can load and display efficiently. **Tools:** meshes, material simplification, GLB export, target-engine inspection. **Difficulty:** intermediate.

Astra can name parts, apply export settings, and compare counts. A triangle is the simplest polygon used for rendering. Material changes and separate objects can also affect performance, so triangle count alone is insufficient.

**Prompt:** “Export this spacecraft as GLB using simple Principled materials. Exclude the studio floor and lights. Report triangles and check the file in a viewer.”

Human review covers silhouette, material appearance, origin, orientation, collision requirements, and performance on the target device. **Astra evidence and tested here.**

### 3D printing

**Output:** a mesh suitable for review in a slicer. **Tools:** manifold geometry, dimension checks, STL or another supported format, slicer. **Difficulty:** intermediate to advanced.

A manifold surface is consistently connected and encloses a printable volume. A render can hide holes, internal faces, and impossibly thin details. Use measured dimensions and inspect the exported file at actual scale.

**Prompt:** “Prepare this simple enclosure as a printable shell. State wall thickness, check non-manifold edges, and flag unsupported overhangs. Do not claim printability until the slicer preview is checked.”

The printer, material, tolerances, and orientation determine the real result. **Proposed application; no print was produced for this guide.**

### Repetitive production and batch processing

**Output:** consistent variants, renamed objects, organized files, thumbnails, or multiple camera renders. **Tools:** `bpy`, background execution, logs. **Difficulty:** moderate setup, low repeat effort.

These are useful early automation targets because acceptance criteria are concrete. Ask for a manifest listing each input, output, and status, and prevent accidental overwrites.

**Prompt:** “Render the same product in five named material variants. Preserve the camera, exposure, and dimensions. Save each output under its variant name and report failures individually.”

Watch for jobs writing to the same path, hidden active-camera changes, and failed renders mistaken for completed files. You check a representative visual sample and every expected filename. **Proposed extension of the tested script route.**

<a id="examples"></a>

## 7. Real examples and what they establish

The most useful examples expose enough process to learn from. We found fewer than eight independently supportable cases, so this section keeps four strong records instead of padding the list with inaccessible social clips. Two are official demonstrations, one is an original community build report, and one is a creator-reported character experiment.

### Thomas Ricouard’s Solace architectural scene

**Published:** September 4, 2026. **Source:** [Architectural visualization with Astra](https://learn.chatgpt.com/blog/architectural-visualization-with-astra).

The article reports Astra in Codex using Blender Python, background execution, and computer use. We inspected its solid cutaway image: furnished rooms and a courtyard are visibly represented in geometry. The workflow develops a plan, models the house, reviews renders, and transfers it into Unreal Engine 5. Blender supplies geometry and Cycles imagery; Unreal supplies an interactive walkthrough, translated materials, collision, and interactions. Imported Poly Haven assets supplement authored geometry.

The post provides selected prompts edited for clarity, not a complete replay log. It documents human direction and multiple passes; total runtime, cost, full iteration count, and downloadable source-project availability were not established here. The rendered tour and Unreal walkthrough are different outputs.

**Why learn from it:** inspect a floor plan before furnishing, then inspect solid geometry before judging materials. Our beginner adaptation is one room with an unobstructed camera path. Do not start by requesting an entire construction-ready house.

### Thomas Ricouard’s Void Explorer spacecraft

**Published:** September 4, 2026. **Source:** [Building games with Astra](https://learn.chatgpt.com/blog/how-to-build-games-with-astra).

We inspected the published concept image and Blender render: both show a pale spacecraft with four distinct wings, while the render reveals its twin rear engines. The author identifies Astra and Codex. Blender creates the authored ship; TypeScript, Vite, and Three.js handle the game, with WebGPU rendering. The reported source contains 193 editable meshes; the export has 14,968 triangles and eight opaque material batches.

Selected prompts and a playable showcase are linked. The full source project, total cost, runtime, and complete iteration count were not verified. The author supplies visual direction and playtesting. A performance comparison elsewhere in the post uses SwiftShader software rendering, so it is not a consumer-GPU frame-rate benchmark.

**Beginner adaptation:** make one ship, export it, and inspect it before adding gameplay. The same post’s Sunwake boat also uses Blender, but its procedural ocean is a Three.js system. Hollowflux is described as code-drawn 2D art, so we do not count it as a Blender example.

### WuTian’s Fluffy Grove room

**Published:** September 4, 2026, with follow-up discussion September 5. **Source:** [Original LINUX DO build report](https://linux.do/t/topic/2857364).

WuTian reports three rounds: a reference-led room and camera path, an exterior pass, then interior-detail corrections. The discussion identifies Windows, initial computer use, and subsequent Python-driven work. A linked page describes a 26-second tour. We read the original text, but did not inspect the complete video or source scene; visual quality and mesh correctness are therefore not independently established here.

The creator specifically acknowledges floating objects and differences seen from other angles. The post is useful because it describes both the appealing overall result and residual defects. Exact cost and render duration are not disclosed beyond saying rendering took a long time. Full prompts and project files were not verified.

**Beginner adaptation:** use one room, save a preview at the start, middle, and end, then inspect furniture contact with the floor. Treat the three rounds as this creator’s experience, not a promised completion schedule.

### bGivenb’s reference-led cheetah experiment

**Publication date:** the fetched page displayed a relative timestamp rather than a stable absolute date; checked September 5, 2026 Pacific time. **Source:** [Original r/aigamedev post](https://www.reddit.com/r/aigamedev/comments/1w7teki/i_tried_the_gpt6_cheetah_challenge_with_a/).

The creator reports using GPT-6 in Codex to rig an imported cheetah, with a Grok-generated running video as reference. The post credits the original cheetah to Poly by Google under CC BY 3.0. It claims a six-second Blender animation and 31 rig controls, while acknowledging rubbery deformation. We read the original workflow text but did not inspect the full comparison video or project.

The creator says no manual rigging or corrective follow-up was performed after the supplied reference. That is a creator claim, not our reproduced result. Full execution logs, costs, and project files were not established. The underlying mesh was imported; it should not be credited as native Astra modeling.

**Beginner adaptation:** try a rigid robot first, then review extreme poses. This example is interesting for reference-led iteration, but it does not establish AAA character quality.

### Ranking the evidence without invented scores

| Example | Visual impact we could inspect | Reproducibility from published material | Beginner accessibility | Content-creation usefulness |
|---|---|---|---|---|
| Solace | Strong furnished cutaway evidence | Process and selected prompts; no complete replay verified | Start with one room | Best reference for architectural B-roll and tours |
| Void Explorer ship | Strong concept/render comparison | Asset statistics and process; not a complete source package | One standalone ship is manageable | Best reference for asset-to-runtime workflows |
| Fluffy Grove | Full media not inspected | Original iteration narrative | A compact room is approachable | Useful account of review and correction |
| Cheetah experiment | Full media not inspected | Original workflow and licensed-model credit | Character rigging is advanced | Useful caution about deformation quality |

Solace leads for understanding scene development; the spacecraft leads for learning export discipline. The independent reports are valuable process evidence, but we do not rank unseen media above inspected images.

### The supplied X leads and other research limits

We attempted the original posts by [Sharif Shameem](https://x.com/sharifshameem/status/2095653641164329143), [Tom Krcha](https://x.com/tomkrcha/status/2095756085890310311), [Anshu](https://x.com/anshuc/status/2096008086901113339), and [Brian Chew](https://x.com/brianchew/status/2096119046840479996). The research tool could not retrieve them. Their media, prompts, dates, runtimes, and costs remain unverified here.

Searches also covered YouTube, GitHub, creator sites, and Blender-related communities, using Astra Blender, GPT-6 Blender, Astra bpy, Codex Blender MCP, and Astra Blender computer use. We excluded unrelated Astra products, older film references, repost summaries, and videos whose original evidence could not be inspected. The older Blender MCP workflow is technical background, not proof of Astra-specific performance.

We link original demonstrations rather than republishing their images without an established reuse basis. The images accompanying our tutorials are original renders from the downloadable project.

<a id="project-a"></a>

## 8. Project A: a studio product hero image

**Brief:** make a clean image of a fictional AI mini PC suitable for a thumbnail, explainer, or sponsor concept. **Prerequisites:** the quickstart and Blender 5.2.1. **Assets:** original generated geometry and simple materials from the included MIT-licensed script. There are no external textures or real-brand assets.

![Original mini PC studio preview](blender-astra-starter/previews/product_0001.png)

*Tested starter output, rendered in Blender. The product is fictional and the geometry remains editable.*

### Initial prompt

> Use the Kingy.ai product starter in Blender 5.2.1 LTS. Create a fictional 140 × 100 × 45 mm mini PC with a titanium enclosure, graphite top, and cyan status strip. Keep the enclosure, top, controls, and strip separate. Place it on a warm circular plinth against a dark studio floor. Use an elevated three-quarter camera. Save the editable project and render a 960 × 540 preview. No external assets, branding, or unapproved downloads.

If you want the most predictable result, run the supplied builder first. A free-form prompt can produce a different design; the script gives you a known baseline that Astra can explain and modify.

### Execution and milestones

1. Complete the quickstart, or open the supplied `scenes/product_v001.blend`.
2. In the Outliner, inspect the product collection. Select the enclosure and inspect its dimensions. This is the **geometry milestone**.
3. Enter camera view. Confirm there is space around the product and that the plinth supports it visually. This is the **composition milestone**.
4. Inspect the supplied PNG at its actual size. The front should remain distinguishable from the top, and the cyan strip should be visible. This is the **lighting milestone**.
5. Save a copy as `product_v002.blend` before changing the design.
6. In **Render Properties**, use Cycles. For a final still, try 64 samples as a starting point; increase only if noise remains visible at delivery size. Keep denoising enabled.
7. In **Output Properties**, set 1920×1080 at 100%. Set PNG and RGBA if you want to retain an alpha channel.
8. Choose **Render → Render Image**. When the Render Result appears, use **Image → Save As** in that image window and save `exports/product_hero.png`.
9. Reopen the saved `.blend` to confirm the scene remains available independently of the render.

A render existing in Blender’s Render Result is not automatically a PNG saved at your desired filename. The builder explicitly writes its previews; a manual still render needs the save action above.

### Make one change at a time

To test a warmer finish:

> Keep the camera, dimensions, top panel, and indicator unchanged. Change only the housing material to a warm ceramic finish. Save product_ceramic_v001.blend and render a preview using the same exposure and lighting.

To improve readability:

> The housing and plinth are too similar in brightness. Preserve geometry and camera. Adjust only the plinth material so the product silhouette is clearer. Show the old and new previews at the same size.

Do not combine a new lens, different background, added props, and a redesigned product in one correction. You would no longer know which change improved the image.

### Quality checks and fixes

Check that the object touches the plinth, the front details sit on the correct surface, and highlights do not erase the lid. Inspect the corners closely: exaggerated bevels can make a metal enclosure look inflated. If the product looks too small, first crop or move the camera; do not scale the physical model merely to fill the frame.

If the stage is black, verify that the correct scene and camera are active and that the lights are enabled for rendering. If the image differs from the viewport, remember that solid shading ignores the actual lighting. Compare a rendered preview with a rendered preview.

**Deliverables:** `product_v001.blend` or your versioned revision, the builder script, `product_0001.png`, and your final `product_hero.png`. The downloadable package contains the tested baseline; later aesthetic variations are your own iterations.

<a id="project-b"></a>

## 9. Project B: an eight-second product animation

**Brief:** an intentional camera move across the front of the same mini PC. **Specification:** 1920×1080, 24 fps, frames 1–192. **Prerequisites:** Project A and enough disk space for an image sequence. **Assets and license:** the same original starter assets.

Eight seconds at 24 frames per second is 192 frames. Blender’s inclusive range 1 through 192 contains exactly that many images. Starting at 0 and ending at 192 would give you 193.

### Initial prompt

> Make an eight-second product animation from the starter at 1920 × 1080, 24 fps, frames 1–192. Move the camera from a right-front elevated view to a left-front view, easing at the beginning and end. Keep the product stationary, the cyan indicator visible, and the lighting deliberate. Preserve the enclosure dimensions. Render frames 1, 96, and 192 before the full sequence. Save animation_v001.blend.

### Build and inspect

1. Open the builder in Blender’s Text Editor.
2. Change `PROJECT = 'product'` to `PROJECT = 'animation'` and choose an empty output root, or open the supplied animation file.
3. Run the script. It saves the animated scene and renders three preview frames.
4. Open `previews/animation_0001.png`, `animation_0096.png`, and `animation_0192.png`.
5. Check that the product stays inside the camera frame and the lighting remains readable from both sides.
6. Reopen `scenes/animation_v001.blend`. Drag the timeline playhead between frames 1 and 192. In camera view, the camera should travel while the product stays still.
7. Press Space with the pointer over the viewport to preview playback. If the laptop cannot display every frame in real time, do not mistake the dropped viewport frames for missing animation keys.

The supplied motion samples a smooth easing curve at every frame. That makes its intended positions explicit and avoids relying on a particular version’s animation-curve editing API. It is a teaching camera move, not a complete cinematic rig.

### Refine the shot

> Preserve the product and lights. The end frame feels too low. Raise only the final camera position slightly, retain a smooth transition, and rerender the three checkpoint frames. Do not reset the opening shot.

Or:

> The movement is distracting. Reduce the travel distance by one third while retaining the eight-second duration and easing. Keep the camera aimed at the product center.

For a motion-graphics explainer, animate an indicator or label after the camera is approved. A second moving element makes the first pass harder to judge.

### Render an image sequence

1. Reopen the saved animated scene so its full-resolution settings are restored.
2. In **Output Properties**, confirm **1920**, **1080**, **100%**, and **24 fps**.
3. Confirm the frame range is **Start 1**, **End 192**, **Step 1**.
4. Set the output path to your `exports/animation_frames/frame_` prefix. In the supplied file, the relative path points from `scenes` back to `exports`.
5. Use **PNG**. Start with the included Cycles settings; 16–32 samples with denoising is a practical first sequence for this simple scene.
6. Choose **Render → Render Animation**. Expect the computer to remain busy while each frame is computed.
7. Verify that filenames run from `frame_0001.png` through `frame_0192.png`, with no gaps.

A PNG sequence lets you recover from an interrupted render without losing the entire movie. Do not delete completed frames because the final job stopped. Determine the first missing frame and render the remaining range.

### Encode the MP4

FFmpeg is a separate video utility. Use an official build linked from [FFmpeg downloads](https://ffmpeg.org/download.html), then confirm `ffmpeg -version` in your terminal. With the terminal’s working directory set to the project root, run:

```bash
ffmpeg -framerate 24 -start_number 1 -i exports/animation_frames/frame_%04d.png -frames:v 192 -c:v libx264 -crf 18 -pix_fmt yuv420p -movflags +faststart exports/product_8s.mp4
```

This command works in Terminal or PowerShell when `ffmpeg` is on PATH. The `%04d` means a four-digit frame number. The input rate matters: encoding the same 192 frames at 30 fps would shorten the shot to 6.4 seconds. Do not simply change the output rate and assume timing is preserved. [FFmpeg image-sequence documentation](https://ffmpeg.org/ffmpeg-formats.html#image2-1).

Play the MP4 in a video player. Check the start, full move, and ending; inspect for flicker, abrupt speed changes, and clipped objects. A correct duration does not prove the shot looks good.

**Deliverables:** editable animation `.blend`, three preview images, the PNG sequence when rendered, and an eight-second MP4. A practical time estimate should come from timing several representative full-resolution frames on your own machine, then multiplying by 192 and adding room for initialization and encoding. Model-response time is separate.

<a id="project-c"></a>

## 10. Project C: a furnished room with a camera tour

**Brief:** a warm, compact living-room cutaway with a sofa, coffee table, rug, shelf, lamp, plant, and a human-height camera move. **Prerequisites:** the earlier projects. **Assets:** original primitive geometry and flat material values. **Difficulty:** intermediate.

![Original furnished room preview](blender-astra-starter/previews/room_0001.png)

*The starter is intentionally a simple cutaway with an open front and right side. It is a learning scene, not a photorealistic house or construction plan.*

### Initial prompt

> Build a 6 × 5 m furnished room cutaway in Blender 5.2.1. Include a sofa, coffee table, rug, shelf, floor lamp, and stylized plant. Use warm plaster, timber, and muted green upholstery. Keep the front and right side open for inspection. Add an eight-second camera approach at 1.65 m height, 24 fps. Render start, middle, and end previews before a complete tour. Name all furniture and keep it editable.

### Establish the layout

1. Set `PROJECT = 'room'` in the builder and run it into an empty project root, or open the supplied room `.blend`.
2. Inspect the room from above using **View → Viewpoint → Top**.
3. Confirm the floor is 6 m by 5 m and the two walls are 3 m high.
4. Check furniture placement before improving finishes. The coffee table should sit in front of the sofa; the shelf and lamp should not block the camera path.
5. Hide a collection temporarily if you need a clearer view, but restore visibility before rendering.

The first milestone is a understandable layout. A beautiful render cannot compensate for a sofa embedded in a wall or a camera passing through the table.

### Review the tour

1. Open the three preview PNGs in `previews`.
2. Compare frame 1’s wide composition with frame 192’s closer sofa view.
3. In Blender, scrub the timeline in camera view. The camera advances from outside the open front toward the furniture.
4. Use solid shading to inspect object contact with the floor. The plant is a stylized cluster of primitive leaves; it does not claim botanical accuracy.
5. Save your revision before adding detail.

For a more believable close-up:

> Preserve the room dimensions, sofa placement, camera route, and color palette. Improve only the upholstery geometry so the cushions have softer, more convincing profiles. Show a close preview without adding cloth simulation.

For better lighting:

> Keep the architecture and camera unchanged. Make the right-side light read as a broad window source. Retain soft shadows and avoid washing the walls into flat white. Render the start and final frames for comparison.

If a shelf appears to float, inspect its mounting and thickness in solid mode. If a rug intersects the floor, raise it by a small measured amount rather than an arbitrary large distance. If the camera cuts through a wall, change the path; hiding the wall in the render may conceal the problem without solving the intended tour.

### Finish the room

Render the full sequence using the Project B procedure, replacing the output folder with `exports/room_frames`. Encode it with the same FFmpeg command after changing the input folder and output filename to `room_8s.mp4`.

For a longer tour, choose specific destinations before extending the timeline: entrance, seating area, shelf detail, and return to the wide view. Multiple short shots with cuts are often easier to direct than one continuous camera path through a whole building.

**Deliverables:** `room_v001.blend`, start/middle/end previews, optional full PNG sequence and MP4, and any licensed textures you later add. The included room is tested through its checkpoint renders and reopening; a complete room movie is a reader-rendered extension unless specifically listed in the testing record.

<a id="project-d"></a>

## 11. Project D: a stylized spacecraft exported as GLB

**Brief:** a small fictional craft with a pale hull, dark cockpit, four wings, and cyan tips. **Prerequisites:** the builder and Blender’s glTF exporter. **Assets:** original geometry; no external model or texture. **Difficulty:** intermediate.

![Original spacecraft preview](blender-astra-starter/previews/spacecraft_0001.png)

*The starter’s studio render. The exported GLB contains the craft, excluding the studio floor, camera, and lights.*

### Initial prompt

> Create a stylized spacecraft for a small game prototype in Blender 5.2.1. Use a pale hull, dark canopy, four separate wings, and cyan tips. Keep the source parts editable. Use simple Principled materials that can export to GLB. Export only the spacecraft, then import it into a fresh scene and report mesh and triangle counts. Do not claim it is game-ready until it has been checked in its target runtime.

### Build, export, and inspect

1. Set `PROJECT = 'spacecraft'` and run the builder, or open the supplied spacecraft `.blend`.
2. Inspect top, front, and side views. Look for wing symmetry and a readable silhouette.
3. Select the product collection’s objects. Keep the floor and lighting out of the export selection.
4. The builder automatically writes `exports/spacecraft.glb`. To export manually, use **File → Export → glTF 2.0**, choose **GLB**, and enable the option to export selected objects only.
5. Use an export copy or the exporter’s modifier evaluation option when converting rounded edges into final geometry. Preserve the `.blend` with its editable modifiers.
6. Create a fresh Blender file and use **File → Import → glTF 2.0** to import the GLB.
7. Check that the cockpit, wings, and cyan tips survived and that the floor was excluded.

The native glTF exporter supports recognized material structures; arbitrary Blender procedural shaders do not automatically become equivalent runtime shaders. This starter intentionally uses simple material values. GLB is a binary glTF container; it is convenient for passing a compact asset between tools. [Blender glTF manual](https://docs.blender.org/manual/en/5.2/addons/import_export/scene_gltf2.html).

### Check it in a viewer or runtime

Use a local glTF viewer you trust, such as a local installation of the [Khronos glTF Sample Viewer](https://github.com/KhronosGroup/glTF-Sample-Viewer), or the engine you plan to use. The independent browser viewer was not used for this package; validation stayed local in Blender. A local Blender re-import checks one path; another renderer checks assumptions that Blender itself may hide.

Orbit around the model and inspect the underside. Check that surfaces do not disappear unexpectedly, the origin is sensible, and the craft points in the direction your game expects. Place it next to a known-size reference object. Different scene axes and camera defaults can make a correct model appear sideways or tiny.

For this package, the exported file was re-imported into a fresh Blender scene and rendered locally for visual inspection: **15 meshes, 4,948 triangles, and five materials** were observed. That establishes a successful export/import, not a performance guarantee or a complete collision setup.

If export looks wrong, use:

> Compare the saved Blender spacecraft with the imported GLB. Report missing objects, material differences, dimensions, and orientation. Fix only the export copy. Keep the editable source intact and rerun the same check.

For a game, ask separately for collision shapes, level-of-detail variants, and target-device performance measurements. A craft that renders well in a studio still needs those decisions before release.

**Deliverables:** `spacecraft_v001.blend`, `spacecraft.glb`, a preview PNG, and an export-check record. The source and exported asset have different roles: keep both.

<a id="prompting"></a>

## 12. Prompting and visual iteration

A useful prompt describes both the intended image and the structure behind it. “Make it amazing” gives the agent no testable target. “Keep the 140 mm enclosure editable and visible through an eight-second move” does.

Use this reusable template, replacing the bracketed fields:

```text
Blender version: [exact version]
Execution route: [I run the script / local agent / computer use / verified MCP]
Project root: [absolute folder]
Subject and purpose: [what it is and where the result will be used]
References: [images, measured dimensions, source links, licenses]
Scale: [units and key dimensions]
Geometry: [separate objects, modifiers, topology expectations]
Materials: [surface finishes and export requirements]
Lighting: [mood, direction, contrast, visible fixtures]
Camera: [angle, lens if known, framing, safe margins]
Animation: [duration, fps, frame range, moving elements]
Constraints: [preserve existing elements, asset restrictions, budget]
Outputs: [.blend, previews, images, sequence, video, GLB]
Acceptance: [what I can inspect to decide it is correct]
Before final rendering: show a low-resolution preview and report uncertainty.
If a tool is unavailable: say what I must do manually.
```

### The five-step review loop

1. **Establish the structure.** Review a simple solid scene. Check scale, silhouette, and layout before surface detail.
2. **Inspect a camera preview.** Look at the actual output frame, not only a free-orbit viewport.
3. **Improve one category.** Choose geometry, materials, lighting, camera, or timing. Preserve the others.
4. **Compare before and after.** Use the same resolution and viewpoint. Changing the presentation can hide whether the correction worked.
5. **Save the accepted version.** Give it a new filename and a short description. Use that file as the next baseline.

A completed script can still have an empty camera view, flat lighting, an intersecting chair, or a missing texture. Software checks answer questions such as “does a camera exist?” Images answer “is the subject readable?” You need both.

When reporting a visual problem, identify its location and effect: “the top-left corner of the enclosure disappears into the background” is actionable. For geometry, ask for orthographic top and side views; orthographic views remove perspective size changes, making proportions easier to compare. For animation, give a frame number or timestamp.

If an iteration improves the housing but damages the camera, restore the accepted camera from the previous file or ask for a narrowly scoped script that changes only the housing material. Rebuilding the entire scene for every correction makes stable progress harder.

<a id="prompt-library"></a>

## 13. The complete prompt library

These 32 prompts are original starting points. **Manual** means Astra supplies code and you run it. **Local** means a local agent can execute Blender and inspect output. **Visual** means attach the relevant render or use an approved computer-use connection. A verified MCP bridge can substitute for local execution where it exposes the required tools. None of the prompts implies an unavailable tool exists.

### First scenes

**1. Explain the starter.** Input: `build_scene.py`. Route: Manual.

> Explain this Blender 5.2.1 script as if I have never used Python. Identify the project selector, output folder, geometry creation, camera, lighting, save, and render steps. Tell me exactly where to run it in Blender. Do not change it yet.

**2. Minimal connection test.** Input: empty project and output path. Route: Local or verified MCP.

> Create one mesh named Astra_Connection_Test, assign a blue material, add a camera and area light, save a new .blend, and render a small PNG. Reopen the saved file and confirm the object is still a mesh. Report each output path.

**3. A simple desk scene.** Input: empty project. Route: Manual or Local.

> Build a small desk with a lamp and fictional AI speaker using primitive geometry. Keep every object named and editable. Use meter units and a camera that shows all three. Render one 960 × 540 preview before adding detail.

**4. Learn by changing one parameter.** Input: product starter. Route: Manual.

> Show me how to change only the product’s housing roughness. Explain what lower and higher roughness should look like under the same lights. Save two preview images with identical camera settings so I can compare.

### Product visuals

**5. A wearable concept.** Input: fictional dimensions and brief. Route: Local.

> Model a fictional 45 mm wide AI wearable puck with a separate clip, faceplate, and indicator. Use restrained ceramic and metal materials. State assumptions about thickness. Keep it clearly labeled as a concept, with no real-brand marks.

**6. A family of finishes.** Input: approved product `.blend`. Route: Local.

> Create three material variants named Graphite, Warm Ceramic, and Titanium. Preserve geometry, camera, exposure, and lights. Save one .blend and PNG per variant. Stop if an output filename already exists.

**7. Sponsor presentation image.** Input: approved fictional product. Route: Local plus Visual.

> Compose a 16:9 hero image with the product on the right and clear space on the left for presentation text. Keep the whole product visible. Avoid invented logos or performance claims. Show a preview before final resolution.

**8. Exploded assembly.** Input: a product with separate parts. Route: Local.

> Make an illustrative exploded view of the existing parts, with a small controlled separation along Z. Preserve each part’s shape and record its original position. Do not invent internal electronics. Save a separate scene and a still preview.

### Reference modeling

**9. Reference audit.** Input: front, side, and top images. Route: Visual.

> Compare these references before modeling. Identify matching landmarks, perspective distortion, missing surfaces, and conflicting dimensions. List which features can be modeled confidently and which require an assumption.

**10. Silhouette first.** Input: references and one real dimension. Route: Local.

> Build only the main silhouette and large components from these views. Use the supplied width to establish scale. Render front, side, and three-quarter solid views. Do not add textures, screws, or small decorative detail yet.

**11. Targeted proportion correction.** Input: reference and preview. Route: Visual then Local.

> The body is too tall relative to the reference. Compare the height-to-width ratio, state the proposed correction, and change only the body and dependent mounting positions. Preserve camera and material settings for comparison.

**12. Real-product accuracy review.** Input: official dimensions and photographs. Route: Visual.

> Review this model against the official references. Check dimensions, port count, button placement, logos, surface finish, and camera perspective. Separate confirmed mismatches from uncertain details. Do not describe the render as an accurate product depiction until those are resolved.

### Interiors

**13. Floor-plan blockout.** Input: room dimensions. Route: Manual or Local.

> Create a 6 × 5 m room blockout with a 3 m ceiling and one clearly marked entrance. Add simple furniture bounding boxes and show a top view. Keep walking clearance visible before modeling detailed furniture.

**14. Furnish a stable room.** Input: approved blockout. Route: Local.

> Furnish this approved layout with a sofa, table, lamp, and shelf. Preserve walls and door positions. Keep furniture at plausible human scale and show both a top view and a camera preview. Use original simple geometry.

**15. Natural interior lighting.** Input: room scene and preview. Route: Visual then Local.

> Keep the layout and camera. Make the main light read as daylight from the open right side, with softer indirect fill. Preserve detail in bright walls and avoid a uniformly illuminated room. Render before-and-after previews.

**16. Collision and contact review.** Input: furnished room. Route: Local plus Visual.

> Inspect furniture contact with the floor, wall intersections, and the camera path. List each visible collision with its object name. Correct only those problems and rerender start, middle, and end camera frames.

### Animation

**17. Eight-second camera shot.** Input: product scene. Route: Local.

> Animate a gentle camera move over frames 1–192 at 24 fps and 1920 × 1080. Keep the product stationary and centered with safe margins. Ease at both ends. Produce three checkpoint previews before rendering every frame.

**18. A readable reveal.** Input: separate product components. Route: Local.

> Make the faceplate rise slowly to reveal the existing interior cavity, then return. Use an eight-second timeline and keep the camera fixed. Do not add undocumented electronics. Check that no part passes through another part.

**19. Loop planning.** Input: intended loop subject. Route: Manual or Local.

> Propose a seamless 120-frame loop at 24 fps. Explain how the first and last sampled positions avoid a duplicated hold frame. Keep the motion simple, and provide a preview sequence before final rendering.

**20. Timing repair.** Input: clip and frame range. Route: Visual.

> The move accelerates too abruptly near the middle. Identify the affected frame range and propose a smoother timing curve. Preserve the opening and final compositions, duration, and all materials. Change only animation timing.

### Procedural environments

**21. Small island.** Input: no assets. Route: Local.

> Create a stylized island with a clear beach, three rock forms, and a small cluster of instanced trees. Use a fixed seed. Keep the scene compact enough for 960 × 540 previews and expose the main terrain parameters.

**22. Geometry Nodes panels.** Input: a base surface. Route: Local.

> Create a Blender 5.2 Geometry Nodes system that distributes solar-panel instances across this surface. Expose count, spacing, tilt, and seed. Label the node groups and explain how to change one control without rebuilding the graph.

**23. Repeated furniture.** Input: one approved chair. Route: Local.

> Arrange twelve instances of this chair in a meeting layout. Preserve shared geometry where possible and keep spacing consistent. Show a top view and report how many unique mesh data blocks are used.

**24. Environment budget.** Input: heavy landscape scene. Route: Local.

> Identify which objects and textures dominate scene complexity. Propose one reduction that preserves the approved camera view, such as instancing or less off-camera detail. Measure the result on the same preview before further changes.

### Troubleshooting prompts

**25. Poor framing.** Input: render and `.blend`. Route: Visual then Local.

> The subject is clipped at the right edge. Preserve geometry and lights. Adjust camera position or lens so the entire subject fits with a modest margin. Show the corrected camera preview and report what changed.

**26. Flat lighting.** Input: render. Route: Visual then Local.

> The front and side have almost identical brightness. Preserve camera and materials. Reduce fill or change key direction to reveal the form, while keeping shadow detail. Make one preview with the same exposure.

**27. Distorted geometry.** Input: problematic object and screenshots. Route: Visual then Local.

> Inspect this object in solid and wireframe views. Check unapplied scale, bevel width, normals, and intersecting parts. Identify the cause before changing topology. Preserve dimensions and save the fix as a new file.

**28. Missing textures.** Input: scene and asset folder. Route: Local.

> List missing image dependencies and their expected paths. Search only the supplied asset folder, relink matches, and report unresolved files. Do not download replacements silently. Reopen the saved scene to verify the fix.

**29. Wrong scale.** Input: exported asset and known dimension. Route: Local.

> Compare this asset’s imported dimensions with the supplied measurement. Explain any meter/centimeter conversion. Correct the export workflow, preserve the editable source, and verify the new import beside a one-meter reference cube.

**30. Excessive render time.** Input: render settings and timed frame. Route: Local.

> Separate model work from Blender rendering time. Inspect resolution, samples, subdivision, textures, and device selection. Propose the smallest quality reduction likely to help, then time the same frame before and after. Do not start a paid render service.

### Export

**31. GLB delivery.** Input: finished object collection. Route: Local.

> Export only the selected asset collection to GLB with compatible materials. Keep cameras and studio lights out. Re-import into a fresh scene, check dimensions and orientation, and report mesh, material, and triangle counts.

**32. Sequence completion and MP4.** Input: rendered PNG folder. Route: Local.

> Check that frames 0001–0192 exist with no gaps and share 1920 × 1080 dimensions. Encode exactly eight seconds at 24 fps as H.264 MP4. Verify the resulting duration and frame count, then play the clip to inspect the full move.

<a id="finishing"></a>

## 14. Finishing, exports, and rendering choices

### Keep the editable source and its dependencies

Save the `.blend` before rendering and again after an accepted design change. To move a texture-based project, use **File → External Data → Pack Resources** where applicable, then save. Packing does not guarantee every simulation cache, linked library, or external resource has been included. Keep those dependencies with the project and test from a different folder. [Blender packed data](https://docs.blender.org/manual/en/5.2/files/blend/packed_data.html).

Relative paths make a project easier to relocate. In Blender, `//` refers to the folder containing the `.blend`, not the operating system’s root. Our files live in `scenes`, so `//../exports/animation_frames/frame_` points to a sibling exports folder. The starter uses no image textures, so there are no missing texture dependencies to collect.

A versioned filename should mean something. Keep `v001` as the baseline, `v002` as a material change, and `v003` as an approved camera change. Automatic `.blend1` backups are useful, but clear intentional versions are easier to discuss with an agent.

### Transparent images

For a transparent background, enable **Render Properties → Film → Transparent**, use **PNG**, and choose **RGBA**. Alpha is the transparency channel. A visible floor or plinth remains visible geometry; Film transparency does not remove it. Hide or separate those objects if you need the isolated product, and inspect edge pixels over both a light and dark background.

For a shadow on a transparent plate, a shadow-catcher workflow needs its own setup and compositing checks. Do not promise that one transparency toggle creates a perfect product cutout with a reusable contact shadow.

### Choose a delivery format deliberately

| Format | Good use | What to check or expect to lose |
|---|---|---|
| `.blend` | Editable Blender source | Blender version and external dependencies still matter. |
| PNG sequence | Reliable rendered frames and compositing | Large storage use; confirm frame numbering and alpha. |
| MP4/H.264 | Video playback and publishing | Lossy compression; typical delivery has no alpha channel. |
| GLB/glTF | Web and runtime assets | Recognized material subset; geometry is triangulated; modifiers and procedural systems do not remain editable graphs. |
| FBX | Many animation and DCC pipelines | Units, axes, bone conventions, material translation, and baked animation need target checks. |
| OBJ | Simple static geometry exchange | No rig or scene animation; materials and texture paths are limited. |
| STL | Geometry transfer for print preparation | No full materials or animation; confirm scale in the slicer and inspect mesh validity. |

For manual exports, use **File → Export** and choose the format. If an exporter is missing, check the version’s built-in import/export support and extensions. Avoid copying old Python operator names from an unrelated Blender release. In current Blender APIs, OBJ and STL operations are under `bpy.ops.wm`; older snippets may use different namespaces. [Window-manager operators](https://docs.blender.org/api/5.2/bpy.ops.wm.html), [FBX and glTF operators](https://docs.blender.org/api/5.2/bpy.ops.export_scene.html).

A reliable handoff includes one known dimension, intended forward direction, material expectations, and an example screenshot. Open the exported file in its destination, then compare those properties. An exporter finishing without an exception is only the first check.

### Cycles and Eevee

**Cycles** traces light paths and is a useful choice for product materials and interior lighting. **Eevee** is designed for interactive rendering and can be useful for previews and stylized sequences. They make different approximations, and switching engines can change reflections, shadows, transparency, and perceived material response. Compare a representative frame before committing to a whole sequence. [Cycles](https://docs.blender.org/manual/en/5.2/render/cycles/index.html), [Eevee](https://docs.blender.org/manual/en/5.2/render/eevee/index.html).

Our practical starting settings are 960×540 previews, 16–32 Cycles samples, and denoising. These are teaching choices, not universal quality standards. For a final still, try higher resolution and increase samples only when the visible result requires it. A sample is another contribution to the image calculation; more samples can reduce noise, but they do not fix incorrect modeling or composition.

Denoising estimates a cleaner image from noisy samples. It can soften fine details, and independently denoised frames can flicker. Judge a moving clip, not just a clean-looking still. If denoising smears vents or labels, use more samples or simplify the material detail before increasing everything indiscriminately.

### GPU rendering

For Cycles, choose a supported device in **Edit → Preferences → System → Cycles Render Devices**, enable the device, then choose **GPU Compute** in the scene’s Cycles device setting. Blender 5.2 documents CUDA/OptiX for supported NVIDIA hardware, HIP for supported AMD hardware, oneAPI for supported Intel hardware, and Metal for supported Apple Silicon Macs. Support depends on OS, GPU generation, and driver versions. [Version-matched GPU guide](https://docs.blender.org/manual/en/5.2/render/cycles/gpu_rendering.html).

Enabling a device in Preferences alone is insufficient if the scene still uses CPU. Conversely, selecting GPU Compute without a compatible enabled device does not guarantee acceleration. Render a test frame and inspect the actual device selection.

For memory failures, reduce large textures, unnecessary subdivision, and duplicate geometry. A high-resolution texture can consume much more working memory than its compressed disk size. Keep the application responsive enough to inspect results. A paid cloud render farm is a separate service with separate costs; none was used for this package.

### Estimate work from a representative frame

Time three frames: a wide shot, the busiest close-up, and the endpoint. Use the slowest or a conservative average for planning. If a representative frame takes 12 seconds, 192 frames would take roughly 38.4 minutes before additional overhead. That calculation is an estimate, not a promised completion time.

Distinguish the time Astra spends planning or executing tools from the time Blender spends rendering. Once a correct scene and render command exist, repeated model requests do not accelerate the renderer. Hardware, scene complexity, settings, and output requirements determine that part of the work.

<a id="troubleshooting"></a>

## 15. Troubleshooting by symptom

| Symptom | Likely cause | Fix | Verify |
|---|---|---|---|
| Astra is absent | Wrong account, client, rollout, or workspace entitlement | Check the actual model picker and current account guidance | Selected model label says GPT-6 Astra |
| Chat provides code but Blender does nothing | No local execution connection | Run the code in Blender, or use a suitable local task | A named object and saved file exist |
| `No module named bpy` | Script ran in ordinary Python | Run with Blender’s Text Editor or executable | Version and scene operations print successfully |
| Executable not found | Incorrect installation path or quoting | Locate `blender.exe` or the app executable; quote the full path | `--version` succeeds |
| MCP tools are missing | Server not configured or not running in this client | Inspect local MCP settings and restart the configured server | `/mcp` shows connected tools |
| MCP cannot reach Blender | Add-on stopped, wrong port, or wrong session | Start the add-on and use matching local connection settings | A single named test object appears |
| `uvx` works in terminal but not app | GUI PATH differs | Configure the absolute executable path | Server starts after client restart |
| Add-on controls differ | Installed version differs from documentation | Compare add-on and server versions; use the original repository | Small connection test passes |
| Python property or socket missing | Blender API changed | Use the exact version’s API and inspect available property names | The smallest failing operation succeeds |
| Operator context error | Wrong mode, active object, or editor context | Return to Object Mode; select and activate the intended object, or use data APIs | Run that operation once in the correct context |
| Output refusal | Builder protects an existing deliverable | Choose a new root folder or deliberate versioned workflow | Existing file stays intact; new file is created |
| Pink or missing textures | External image paths are broken | Relink from the licensed asset folder, then pack or use relative paths | Reopened scene resolves all expected images |
| Black render | Wrong camera, hidden objects, disabled lights, or empty view | Inspect active scene, camera, render visibility, and light energy | Low-resolution camera render shows subject |
| Wrong shot renders | Another camera or scene is active | Select the intended scene and its active camera | Camera view matches the rendered PNG |
| White, featureless product | Excessive illumination or exposure | Reduce exposure or light power and inspect material roughness | Highlights retain shape and surface detail |
| Crashes before Python starts | Application or graphics initialization issue | Test Blender normally and inspect the crash log; check supported drivers/runtime access | A minimal background command reaches Python |
| Render crashes later | Memory exhaustion, unstable driver, or problematic scene element | Reduce texture/subdivision load; isolate the failing frame or object | The same failing frame completes |
| Render is slow | CPU selected, high samples, dense geometry, large textures | Time a representative frame and change one contributor | Same frame improves without a material visual loss |
| Movie is too short | Wrong input frame rate or missing frames | Count frames and encode at the intended input fps | 192 frames at 24 fps gives eight seconds |
| GLB looks different | Unsupported shader or export selection/axis issue | Use compatible materials and inspect the export copy | Fresh import and target viewer agree on key properties |

When asking Astra for a fix, attach the relevant scene or script, error text, version, and one screenshot. State what must stay unchanged. A focused reproduction is usually more useful than a large conversation about everything that might be wrong.

### What feels unproven

Complex character deformation, precise reference reconstruction from sparse images, production topology, dependable material translation, and large unattended sessions remain tasks to verify individually. The examples above do not establish that every beginner prompt will reach professional quality. A beautiful image is evidence of an image; inspect topology, dimensions, rigs, export behavior, and runtime performance separately.

<a id="video-ideas"></a>

## 16. Five achievable Kingy.ai video concepts

These concepts use Blender to explain or illustrate AI hardware and workflows. For real products, check manufacturer dimensions, controls, ports, branding, and materials against reliable references. Label concept visuals and approximations so viewers do not mistake invented hardware for a tested device.

| Video concept and honest title | Hook and on-screen result | Required assets | Difficulty and viewer value |
|---|---|---|---|
| **From Prompt to Editable Mini PC in Blender** | Start with a blank scene, end with a hero render, then reveal its editable parts | Included product starter and screen recording | Beginner; shows what the AI workflow actually produces |
| **One AI Hardware Model, Three Product Looks** | Compare graphite, ceramic, and titanium under identical lights | One approved fictional model and three material presets | Beginner; demonstrates how materials and lighting affect perception |
| **How to Make an Eight-Second Product Shot with Astra** | Show three checkpoint frames, then the finished camera move | Animation starter and rendered sequence | Intermediate; explains timing and iteration without inflated speed claims |
| **A Blender Room Tour Built from a Simple Brief** | Show the floor plan, solid geometry, then a furnished approach shot | Room starter, optional licensed textures | Intermediate; exposes the decisions behind convincing interiors |
| **Does Your AI-Generated 3D Asset Survive Export?** | Compare the Blender spacecraft with its GLB in another renderer | Spacecraft starter and viewer | Intermediate; answers a practical question that glossy demos often leave open |

For thumbnails, use one clear silhouette and leave room for editorial text. For original B-roll, render several short shots from the same scene rather than making unrelated models for every sentence. For sponsor presentations, prepare consistent angles and clearly label any imagined features. A controlled visual system is more credible than a dramatic render that changes the product’s details between shots.

<a id="testing"></a>

## 17. What was actually tested

The core package was executed on **Blender 5.2.1 LTS**, build hash `9e2066aef7ef`, on **macOS 26.3**, an **Apple M4 Pro MacBook Pro with 24 GB memory**. Blender’s bundled Python ran the scripts. No API key, Blender MCP server, third-party model generator, purchased asset, or render farm was used.

| Check | Result |
|---|---|
| Product construction, material assignment, camera, and lights | Executed; 20 mesh objects in the active scene |
| Product preview image | Rendered at 960×540 and visually inspected |
| Product exposure/framing correction | Applied after inspecting the first render; corrected preview inspected |
| Four `.blend` files | Saved, reopened, and checked for an active camera and mesh geometry |
| Product animation | All 192 full-resolution frames rendered in Cycles at 16 samples; encoded as an eight-second 1920×1080 H.264 MP4 at 24 fps |
| Room tour | Start, middle, and end previews rendered; wide and close views inspected |
| Spacecraft GLB | Exported, re-imported into a fresh Blender scene, and rendered for local visual inspection |
| GLB counts on re-import | 15 meshes, 4,948 triangles, five materials |
| Windows/Linux procedures | Documentation-based; not executed on those operating systems |
| Third-party Blender MCP | Documentation checked; not installed or executed |
| Official demonstrations | Published text inspected; specified still images inspected; full source projects not reproduced |

An initial sandboxed Blender launch crashed during Metal initialization before Python executed. Running the same local Blender task with normal hardware access succeeded. This is a host-environment finding, not a general claim that Blender 5.2.1 cannot run in the background.

The product movie was rendered locally as 192 PNG frames, using Cycles CPU rendering with 16 samples and denoising, then encoded with FFmpeg 8.1.1. The included scene retains its 32-sample baseline. The compact ZIP includes the MP4, while the large intermediate PNG sequence is retained separately.

The Python log also emitted a deprecation warning for `Material.use_nodes`, indicating future removal in Blender 6.0. It did not prevent execution in 5.2.1. This is a reason to preserve the tested version and recheck the script before a future major upgrade.

The starter deliberately uses simple forms. Its front details are illustrative, the room has an open cutaway structure, and the spacecraft has no gameplay or collision behavior. Those are defined scope choices, not hidden production-readiness claims.

<a id="appendices"></a>

## 18. Technical appendices

### Run the builder from a terminal

Use absolute paths for your own files. The examples below assume the script is in `Documents/BlenderAstra/scripts`. Replace the account name and choose a new empty output root when rebuilding.

**macOS Terminal:**

```bash
"/Applications/Blender.app/Contents/MacOS/Blender" --background --factory-startup --python-exit-code 1 --python "/Users/YOUR_NAME/Documents/BlenderAstra/scripts/build_scene.py" -- --project product --root "/Users/YOUR_NAME/Documents/BlenderAstraRun01"
```

**Windows PowerShell:**

```powershell
& "C:\Program Files\Blender Foundation\Blender 5.2\blender.exe" --background --factory-startup --python-exit-code 1 --python "$env:USERPROFILE\Documents\BlenderAstra\scripts\build_scene.py" -- --project product --root "$env:USERPROFILE\Documents\BlenderAstraRun01"
```

Replace `product` with `animation`, `room`, or `spacecraft` for the other projects. `--background` avoids opening the normal window. `--factory-startup` gives the process a predictable initial file. `--python-exit-code 1` makes a script exception produce a failing process exit code. The final `--` separates Blender’s options from our script’s options. [Command-line arguments](https://docs.blender.org/manual/en/5.2/advanced/command_line/arguments.html).

These commands run a separate Blender process; they do not modify the scene in an already open Blender window. Open the resulting file to inspect it there.

### A short Linux appendix

Install a supported official Blender build for your distribution and architecture, or use your distribution’s package if it matches the guide’s required version. Extracting an official archive commonly gives you a folder containing a `blender` executable. Run its exact path with `--version` before proceeding.

From a terminal, inside that extracted Blender folder:

```bash
./blender --background --factory-startup --python-exit-code 1 --python "$HOME/Documents/BlenderAstra/scripts/build_scene.py" -- --project product --root "$HOME/Documents/BlenderAstraRun01"
```

Here `$HOME` is only read as the existing account home path. Ensure the directories exist and adapt them to your installation. Check GPU support against the version-matched manual. OpenAI’s cited desktop Computer Use instructions cover macOS and Windows; this guide does not claim Linux desktop computer-use support. The manual-script and local executable routes do not require it. [Linux installation](https://docs.blender.org/manual/en/5.2/getting_started/installing/linux.html).

### What the supporting script does

The included `build_scene.py` is the executable technical appendix. It creates named collections and simple materials, builds a selected project, saves a versioned `.blend`, and renders small previews. Its spacecraft branch exports selected geometry as GLB. Its animation branches create camera positions across 192 frames.

The header documents the editable settings. Functions such as `box`, `cylinder`, `camera`, and `light` make the construction readable. The saved file retains full-resolution settings while temporary preview renders use half resolution. No system Python package is required for the builder.

If you modify the script, preserve the original. Ask Astra to explain a small function before changing it. A readable builder is useful long after the first render because it records how the scene was made.

### Sources and download package

The companion source register records direct links, verification dates, and access limitations. The starter package includes the code, editable scenes, previews, exported spacecraft, and verification record. The separate quickstart provides the shortest path to the first product image, and the prompt-library file repeats the 32 prompts for easy reuse.

Use the source links attached to the relevant instructions when a menu or feature differs. Match your actual Blender version and OpenAI client; never substitute an inaccessible tool with an invented setup step.
