Known Issues

Every other parameter type is one node. A Float, Vector2 or Vector3 parameter carries its value, its row in the InfinioInstance inspector, an optional scene handle picked in the Parameters panel, and a sub-graph input port — all at once, and you never choose between them.

Polygon is split across two nodes that are not interchangeable once placed:

• Scene Polygon gives you the scene drawing tool, but it is not a parameter — it gets no row in the Parameters panel, no visibility or section control, and no row in the instance inspector.
• Sub-Graph Polygon Input is a proper parameter with a row in the Parameters panel, but its handle dropdown is permanently disabled and reads “None (inspector only)”. It is wire-fed only.

So a scene-drawn polygon cannot be exposed to whoever tunes the finished tool, and an exposed polygon cannot be drawn in the scene. Merging the two into one polygon parameter is planned for a post-beta track.

Affected: Polygon parameters only. Float, Vector2, Vector3 and Color parameters all behave normally.

Workaround: Decide which half you need before you place the node — scene drawing, or exposure and wiring. Switching later means deleting the node, placing the other one, and rewiring it; there is no in-place conversion.

If you embed BurstGraphEvaluator and call it directly — the lower-level path for generating geometry from your own code — you get back a report holding raw vertex and index data with no public method to turn it into a Unity Mesh. The upload helper is currently internal, so from outside the assembly there is no supported way to finish the job.

Making that upload path public is scheduled after beta. It is a visibility change, not new machinery.

Affected: Only the raw-evaluator path. Everything driven through the InfinioInstance component uploads its meshes normally.

Workaround: Use InfinioInstance instead: InfinioInstance.Spawn(binary, position, rotation), then Set parameters by stable name and call Evaluate. You still get OnEvaluated and MeshUploaded to hook into, and the mesh is built for you. See Calling Infinio from code for the full pattern.

Infinio needs Burst, Collections and Mathematics. If any of the three is missing, the console fills with CS0246 “type or namespace not found” errors and nothing in them says which package you are short of.

A second version of the same problem: if NodeGraphProcessor is already in your project as well as bundled inside Infinio, you get CS0101 duplicate-definition errors instead, and those also do not name the cause.

Workaround: Hundreds of red errors right after import mean the project lacks Burst, Collections and Mathematics. Add com.unity.burst, com.unity.collections and com.unity.mathematics through Window → Package Manager → + → Install package by name, or start again from the Universal 3D (URP) template.

The Straight Skeleton Roof node now solves a footprint with an interior hole (a courtyard, a lightwell, a stairwell opening) as a real multi-contour roof, so the hole is correctly left open in most cases. You will still see an on-canvas notice on every holed footprint; that notice is informational, not itself a sign of a problem.

On a footprint whose contours the solver cannot validate (self-intersecting edges, contours that touch, a hole not fully inside the outer ring), the roof still falls back to a single pitched roof built from the outer outline alone, silently covering the hole. That fallback case is what this entry tracks; closing it is post-beta work.

Affected: Straight Skeleton Roof given a multi-contour footprint. Single-contour footprints, which is nearly everything, are unaffected.

Workaround: None yet — please report it if the problem is blocking you.

Infinio bundles its own copy of NodeGraphProcessor (NGP) under Assets/Infinio/ThirdParty/NodeGraphProcessor/. Unity’s assembly definition names are globally unique — if you already have NGP installed in your project (for example via the OpenUPM package com.alelievr.node-graph-processor), you end up with two assemblies called com.alelievr.NodeGraphProcessor.Runtime and com.alelievr.NodeGraphProcessor.Editor. Unity refuses to compile two assemblies with the same name and gives a wall of CS0101 duplicate-definition errors.

This is an upstream constraint of Unity’s assembly system: asmdef names are a global namespace and we cannot rename the bundled NGP copy without forking it. The bundled copy is the version Infinio was built and tested against; using a different version may produce compiler errors or runtime behaviour differences.

Workaround: Remove the other NodeGraphProcessor installation before importing Infinio. In the Package Manager, uninstall com.alelievr.node-graph-processor (Window → Package Manager → In Project). If NGP came in as a folder under Assets/, delete that folder. Then re-import the Infinio package.

The package includes a chunk streaming system (Infinio.Chunk) for graphs that generate an endless world around a moving camera. It works, but it is reachable only from C# — there is no scene component, no inspector, and no example. You construct a ChunkSystem yourself and draw the geometry it hands back.

Two behaviours will look like bugs if you try it. Scatter is generated per chunk with no knowledge of its neighbours, so points can crowd or thin along chunk borders. And a graph’s exposed parameters read their authored default in every streamed chunk rather than varying by chunk position.

This is deliberate for the beta. Streaming is not part of what we are asking you to test, and it will not be supported or documented during the beta window.

Affected: Any use of ChunkSystem, ChunkStreamer or LodController from code. Nothing you do in the graph editor touches this, and no example graph uses it.

The three mesh boolean nodes — Geometry → Union, Difference and Intersect — do real CSG and are genuinely useful, but they carry hard architectural limits in this release. No fix is scheduled for beta; improving the CSG kernel is post-beta work.

Five limits, in the order you are likely to meet them:

• 20,000 triangles per operand. Past that the operation is refused outright and the first operand comes back unchanged. The triangle-pair search is brute force, so this cap guards against a multi-minute freeze rather than being an arbitrary number.
• Both operands must be closed, watertight solids. An open sweep tube, a displaced surface, or a mesh with a bad merge is rejected rather than guessed at — and the node then visibly does nothing: Union gives you one operand, Difference gives you A uncut, Intersect gives you nothing.
• Operands must be under about 10,000 units across. Above that the inside/outside test loses float precision, so the node degrades the same way rather than returning a result it cannot stand behind.
• The result is usually watertight, not always. On clean box-like input it holds up; on curved input the seam between the two shapes can be left open and is patched with a fan of triangles from the centre. You will see a warning when that repair fires. It is a patch, not a correct seam, and it can look wrong under smooth shading.
• Only position, normal and the first UV survive. Vertex colours, tangents and UV2–UV7 are dropped, and normals are recomputed from the result — so any smoothing or custom normals you set upstream do not come through.

Separately: the preview in the graph window does not run real CSG for Difference and Intersect. It shows Difference as the uncut first input and Intersect as empty, and says so in the warning strip. The scene view and a built Player both do the real thing — so judge a boolean by the scene view, never by the graph window’s node preview.

Affected: Geometry/Boolean/Union, Geometry/Boolean/Difference, Geometry/Boolean/Intersect. The 2D Polygon booleans are a separate system with separate limits — see the polygon entry on this page.

Workaround: Keep both operands closed solids, under 20,000 triangles and under ~10,000 units across, and keep an eye on the warning strip — every one of the limits above announces itself there rather than failing quietly. Where you can, do the boolean on simple primitives and add detail afterwards, rather than cutting into an already-dense mesh. Check the result in the scene view, not in the graph window preview.

Polygon boolean and offset nodes are backed by our own kernel, and it declines inputs it cannot prove it will get right rather than guessing. The most common trigger is exact tangency — two shapes whose edges touch without crossing, an operand vertex landing exactly on the other operand’s edge, or two coincident edges. That usually happens by construction, not by accident: a rectangle whose width and a circle’s diameter come from the same Multiply will touch exactly, on every evaluation.

When it declines, the node outputs an empty polygon and raises a warning rather than producing a wrong shape. Downstream geometry then comes out missing that piece.

Right now the graph editor quietly repairs these cases and a built Player does not, so a graph can look correct in the scene view and come out with the piece missing in a build. We are removing that split during beta so the editor fails the same way the build does — a shape that disappears in front of you is a problem you can fix; one that only shows up after a build costs you a build cycle to even find. Teaching the kernel to handle these inputs properly is scheduled after beta.

Affected: Polygon/Union, Polygon/Intersect, Polygon/Difference, Polygon/Offset and anything built on them. Shapes that overlap cleanly are unaffected — this is specifically about edges and vertices that coincide exactly.

Workaround: Break the exact touch. Add a small offset — a fraction of a unit is enough — to one operand so the edges cross properly instead of grazing, or drive the two sizes from separate values rather than one shared knob. We use exactly this trick in our own example graphs.

Dragging a new wire out of an output port and releasing on empty canvas offers a sensible shortlist of nodes to create. Doing the same from an input port offers a list that has nothing to do with the port you are wiring — mostly nodes you used recently, or nodes already in the graph.

The suggestion list is scored for the output-drag direction only, so dragging from an input reads the wrong half of that scoring and most of the ranking signal is lost.

Box-selecting two or more objects with an Infinio component showed Unity’s generic “Multi-object editing not supported” message instead of the parameters.

That was more annoying than it sounds, because Duplicate and Randomise exists precisely to leave you with many instances at once, and each one then had to be tuned separately.

On the first import into a project that already contains Infinio graphs, the compiler revision sweep ran against all of them, recompiled each one and saved it. Graph assets are stored as text and run 120–223 KB each, so if the project is under version control you get a large unexplained diff you did not ask for.

Nothing is lost and the graphs are correct afterwards — the recompile is real work, not a spurious rewrite. The problem is that it happened silently and without asking.