OctoShaper - First Unity Procedural Graph Keep Hold After Asset Store Launch 2026

If you are searching octoshaper unity after its mid-August 2026 Asset Store launch, the useful question is not whether node graphs look tidy in a trailer. The useful question is a pipeline decision: can you author one scatter or modular-structure graph in the editor, run the same logic at runtime with GenerateSync / GenerateAsync, override parameters from gameplay code without string-chaos, and is a buy-once Unity-native tool better than Blender Geometry Nodes exports or another custom C# spawner?

OctoShaper is a node-based procedural generation tool for Unity: one graph model for editor and play mode, realtime preview, procedural prefabs, sync or async execution, and an indie-friendly one-time purchase (no subscription). The official product page and runtime generation docs are the authoritative pins; the itch Asset Store announcement marks the beta-to-store moment. An announcement is a ceiling. This tutorial is a floor test on one disposable scene.

This article turns the launch into a 90-150 minute O1-O6 keep/hold lab. You will install OctoShaper into a throwaway project, build a minimal scatter/structure graph, preview in-editor, drive ProceduralGraphExecutor with parameter overrides, compare sync vs async, optional procedural prefab, write honest limits vs Blender GN / Houdini / hand scripts, and save octoshaper_v1_keep_hold_receipt_v1.json. You will not rebuild your whole level pipeline tonight.

Non-repetition: this is not World Machine terrain spike, a terrain DCC keep/hold. It is not UE 5.8 procedural vegetation editor, an Unreal experiment. This URL owns one intent: is OctoShaper worth adopting for Unity editor+runtime procedural graphs after Asset Store launch, tested on one evening with honest hold criteria?

Time estimate: 90-150 minutes. Add 30 minutes if Asset Store import or package resolution fights you.

Default recommendation: keep OctoShaper for Unity-native scatter/modular variation and runtime regen if O1-O4 pass. Hold replacing Blender GN or a battle-tested custom spawner until O5 proves the graph covers your real content types without editor-only assumptions, and until buy-once pricing fits the team.

What OctoShaper actually ships

From the product and docs surfaces:

• Node graphs for structures, growth/branching, scattering/sampling, and runtime variation.
• One graph model for editor authoring and play-mode execution.
• Realtime visual feedback while editing parameters.
• Unity-native - stay in-engine instead of revolving around a separate DCC for day-to-day iteration.
• Procedural prefabs - package graph-driven setups for reuse across scenes.
• Sync and async execution - GenerateSync(), GenerateAsync(), and mode-aware Generate().
• ProceduralGraphExecutor - component API with GenerateOnEnable, parameter overrides by name or Guid, clear/reset helpers.
• Direct bootstrap - OctoShaperRuntime.CreateExecutionContext / CreateExecutor when you want ElementSet output without default scene instancing.
• Commercial model: one-time purchase, lifetime license, no subscription (indie-friendly positioning). Verify current Asset Store / itch price at checkout.
• Roadmap honesty: mesh generation, Godot support, 2D textures, and more are future interests - do not buy for features that are not shipping today.

Monday ritual - one graph, six gates, one decision

If you only have 90 minutes, stop after O3. A graph that regenerates from named parameters is a real evaluation.

Company CapEx four-liner

1. Scope - one seat evaluates on a disposable scene; no level-wide migration tonight.
2. Cost - one-time Asset Store / itch purchase (verify price); no subscription - compare to engineer-weeks of a custom graph tool.
3. Trap - buying for roadmap items (Godot, mesh gen) that are not in v1.0.0; or assuming async means "free" on the main thread.
4. Owner - one engineer owns graph style guide, parameter-name wrappers, sync/async policy, and the Blender GN boundary.

Rough buy-vs-build math (fill real numbers):

Custom spawner maintenance: [N] hours/month × [$]/]
OctoShaper one-time: [$P]
Break-even months ≈ P / (N × COP)   (if Octo removes that maintenance)
If N < 2 hours/month and graphs stay tiny, hold may win.
If three designers already ask for "knobs without code," buy-once usually wins.

Do not count hypothetical "we might need Houdini later" as a reason to reject a $tens tool that unblocks this quarter's scatter pass.

Prerequisites

• [ ] Unity version matching the Asset Store listing (confirm at install).
• [ ] A disposable 3D scene with a few prefab props to scatter or a modular kit.
• [ ] Access to runtime docs while you work.
• [ ] VCS so generated scene content is revertible.
• [ ] Optional: an existing Blender GN or C# spawner for A/B honesty.

Beginner glossary

• Procedural graph: a node network that generates content from rules and parameters.
• ProceduralGraphExecutor: Unity component that runs a graph in play mode / on demand.
• Parameter override: runtime value that replaces an authored graph parameter for one generation.
• GenerateSync / GenerateAsync: immediate vs awaited execution paths.
• ElementSet: OctoShaper's main output collection of generated elements.
• Procedural prefab: imported asset that regenerates from graph inputs.

O1-O6 - the evening smoke in detail

O1 - Minimal graph with live preview

Create a new ProceduralGraph aimed at something tiny: scatter 10-30 props on a plane, or a short modular fence/kit. Expose two parameters you care about (Count, Radius or Width). Tweak them in the editor and confirm the preview updates without a full scene reload.

Check: can a designer understand the graph without reading your Discord lore? Are parameter names human-readable?

Pass O1 when a parameter drag visibly changes the result.

Scatter acceptance tests (run before calling O1 done):

If Count = 0 still spawns junk, fix the graph before wiring runtime - you will otherwise debug "executor bugs" that are authoring bugs.

O2 - ProceduralGraphExecutor + GenerateSync

Add ProceduralGraphExecutor, assign the graph, set GenerateOnEnable = false, then call GenerateSync() from a small driver after setting overrides:

using CuriousTrove.OctoShaper;
using UnityEngine;

public sealed class OctoSmokeDriver : MonoBehaviour
{
    [SerializeField] private ProceduralGraphExecutor executor;

    private void Start()
    {
        executor.GenerateOnEnable = false;
        executor.ExecuteAsAsync = false;
        executor.SetParameterOverride("Count", 12);
        executor.SetParameterOverride("Radius", 4.5f);
        executor.GenerateSync();
    }
}

Check: play mode produces the expected instances; stopping play cleans up or leaves known residue you documented.

Pass O2 when sync generation works from code with Generate On Enable off. This is the backlink magnet: a copyable executor driver vs announcement SERP.

O3 - Named parameter overrides + regen

Add a button or key that changes Count and calls Generate() / GenerateSync() again. Prefer wrapping parameter names in constants:

static class OctoParams
{
    public const string Count = "Count";
    public const string Radius = "Radius";
}

Use TrySetParameterOverride when a missing name should not throw.

Check: second generation replaces or accumulates as you intend (document which); no silent no-op because a renamed parameter broke strings.

Pass O3 when regen from gameplay-shaped code is reliable.

O4 - Sync vs async honesty

Run the same graph once with GenerateSync and once with await GenerateAsync() (set ExecuteAsAsync appropriately). Note hitch length and whether async actually helps your frame budget.

Pass O4 when you wrote which mode you will allow in shipping builds.

Executor mode matrix (paste into the receipt):

Measure hitch with the Unity Profiler once - "feels fine" is not a gate.

O5 - Prefab path + Blender GN / custom-script honesty

Optional: create a procedural prefab from the graph and drop it in a second scene. Confirm it regenerates as documented.

Then fill the honesty table:

For offline terrain and DCC-heavy work, keep World Machine and Blender→Unity export discipline in the stack. OctoShaper is not a Meshy replacement either - AI mesh imports stay on their own keep/holds like Meshy 7.

Pass O5 when the boundary is written for your studio.

O6 - Decision and share note

OctoShaper Asset Store smoke (YYYY-MM-DD)
Unity: [version]  OctoShaper: [v1.0.0]
O1 live preview graph: pass/fail
O2 GenerateSync executor: pass/fail
O3 param regen: pass/fail
O4 sync/async choice: sync / async / both-gated
O5 vs GN/scripts: keep Octo / hold / hybrid
Decision: adopt scatter / adopt runtime / hold

Pass O6 when the note and receipt exist with a named owner. Capture a 5-second clip of a parameter change regenerating content.

Practical guidance the docs want you to remember

From the official runtime guidance, treat these as ship rules:

1. Turn Generate On Enable off when gameplay must apply overrides first.
2. Prefer your own parameter wrappers over scattered string literals.
3. If runtime fails oddly, check whether graph code was regenerated, whether main output is an ElementSet, and whether the graph assumed editor-only data.
4. Choose the surface deliberately: component executor vs direct OctoShaperRuntime bootstrap vs procedural prefab.

Who should hold

• Teams mid-milestone with a working custom spawner - do not rip it out this week.
• DCC-only art pipelines that never need runtime regen - Blender GN may remain primary.
• Anyone buying for roadmap Godot/mesh features - evaluate shipping v1 only.
• Huge open-world streaming until you prove async + budgeting on your content density.

Common mistakes

• Leaving Generate On Enable on while also setting overrides in Start (race / double generate).
• Scattering magic parameter strings across ten scripts.
• Assuming async removes hitch cost entirely.
• Building a 200-node graph on night one instead of a 10-node scatter.
• Treating OctoShaper as a Houdini replacement for film-scale pipelines.

Failure modes cheat sheet

Ship the cheat sheet next to the receipt so week-two on-call is not archaeology.

Troubleshooting order

1. Nothing generates - graph assigned? Generate called? Generate On Enable confusion?
2. Overrides ignored - wrong parameter name; use TrySet and log failures.
3. Editor preview ≠ play mode - editor-only assumptions; regenerate graph code.
4. Hitch on sync - shrink graph or move to async with clear loading UX.
5. Import / asset issues - isolate with 3D model import Blender→Unity if props themselves fail, not the graph.
6. Prefab confusion - confirm you wanted a procedural prefab vs a normal prefab of generated instances.

What teams should do next Monday

Solo indie

• Finish O1-O3 on a greybox scatter.
• Adopt for one biome dressing pass if O4-O5 pass.

Small studio

• One engineer owns parameter-name constants and sync/async policy.
• Designers edit graphs; programmers own executors - write that contract down.

Company

• CapEx: one-time license vs custom tool maintenance.
• Require the smoke receipt before any "replace all spawners" ticket.

Creator

• Post a parameter-slider → regen clip. For broader tooling context, see 25 free tech-art tools and 20 free cross-engine prototype starters.

Graph style guide (copy into the tech bible)

What not to put in an OctoShaper graph (yet)

• Full open-world streaming / paging logic - prove scatter first.
• One-off boss encounters better done as hand-placed prefabs.
• Anything that requires secret server-side seeds you cannot store in a client graph.
• Film-scale destruction sims - wrong tool class.
• "Temporary" debug nodes left enabled in shipping builds - treat graph review like code review.

If a designer asks for a graph that is really a quest script, redirect to gameplay code. OctoShaper wins at content variation, not at narrative state machines. Write that boundary into the tech bible so the next spike does not reopen the same debate under a new graph name.

Key takeaways

1. OctoShaper is a Unity-native node procedural tool now on the Asset Store (product, announcement).
2. One graph model serves editor preview and runtime generation.
3. Drive play mode with ProceduralGraphExecutor and explicit GenerateSync / GenerateAsync.
4. Disable Generate On Enable when overrides must apply first (runtime docs).
5. Wrap parameter names - do not scatter string literals.
6. Sync vs async is a hitch decision, not a fashion choice.
7. Procedural prefabs and direct OctoShaperRuntime bootstrap are alternate surfaces - pick one per system.
8. Buy-once / no subscription - verify price; do not pay for roadmap vapor.
9. Hold replacing Blender GN or tiny custom spawners until O5 honesty passes.
10. Start with a tiny scatter graph, not a world generator.
11. Check ElementSet output and regenerated graph code when runtime fails oddly.
12. A parameter-regen receipt is the cite-worthy artifact.

FAQ - OctoShaper Unity

What is OctoShaper?

OctoShaper is a node-based procedural generation tool for Unity that lets you author graphs in the editor and run the same logic at runtime for structures, scattering, growth, and live variation.

Is OctoShaper subscription-based?

No. The product is positioned as a one-time purchase with a lifetime license. Confirm current pricing on the Asset Store or itch.

Can the same graph run in play mode?

Yes. That is a core claim - editor authoring plus runtime execution via ProceduralGraphExecutor or direct runtime bootstrap APIs.

What is the difference between GenerateSync and GenerateAsync?

GenerateSync runs immediately on the calling path. GenerateAsync is the awaited path for responsive gameplay. Generate() follows the executor's current mode flags. Measure hitch cost on your graph.

Should I use Generate On Enable?

Only when idle auto-run is what you want. For gameplay-driven overrides, turn it off, set parameters, then generate explicitly.

How does OctoShaper compare to Blender Geometry Nodes?

Blender GN is DCC-side authoring with export into Unity. OctoShaper keeps day-to-day iteration and runtime regen inside Unity. Many teams will hybridize - do not force a false either/or.

Does OctoShaper replace Houdini?

No. Treat it as an indie-friendly Unity-native graph tool for game-sized scatter/structure problems, not a film-scale DCC.

What should I check if runtime generation fails?

Regenerate graph code, confirm the main output is an ElementSet, and remove editor-only assumptions - per the official runtime guidance.

Related reading

• Reactive Bones - First Unity Secondary Motion Keep Hold for Indies 2026
• How to Try World Machine Terrain - First Mac/Linux Spike Keep Hold 2026
• Blender to Unity and Godot Export Pipeline - Clean Art Handoff Checklist
• How to Try Meshy 7 Image to 3D - First Indie Alignment Smoke 2026
• 25 Free Tech-Art Tools and Shader-Graph Libraries
• 20 Free Cross-Engine Prototype Starter Projects
• 3D Model Import Issues - Blender to Unity Fix