Plugin Documentation

NoiseGraph
Node-based SIMD noise for Blueprints and C++

Build noise node trees — coherent noise, fractals, domain warps, blends and modifiers — and generate 2D, 3D and 4D noise as single samples, uniform grids, tileable maps or position arrays with a bundled SIMD-accelerated noise library.

v1.0
UE 4.27 & 5.8
Win64 & Linux only
Category Procedural
Alpha XP

Overview

NoiseGraph exposes a node-based noise library to Blueprints and C++. Every node of the library is a UObject generator: create generators with the NoiseGraph factory nodes, plug them into each other through their source inputs, and generate values from the last generator of the tree. Generation runs in the bundled native library, which selects the best SIMD instruction set of the CPU at runtime.

  • Coherent noise: Value, Perlin, Simplex, OpenSimplex2, OpenSimplex2S and three cellular variants.
  • Fractals (FBm, Ridged, PingPong) and domain warps (gradient, progressive and independent fractal warps).
  • 28 blend nodes: add, subtract, multiply, divide, min, max, smooth min/max, exponent and fade with value or source operands.
  • Modifiers: domain scale, offset, rotate and axis scale, seed offset, remap, terrace, RGBA8 conversion, add/remove dimension and a generator cache.
  • Generation as uniform 2D/3D/4D grids, tileable 2D maps, position arrays or single samples, with the min/max range returned.
  • Load complete node trees from encoded node-tree strings.
  • Win64 and Linux (x64) only.

Requirements

RequirementDetails
Unreal Engine4.27 and 5.8 (verified clean on both)
ModulesNoiseGraph (Runtime), plus the bundled prebuilt library module FastNoise2 (external, no code to compile)
DependenciesNone
LanguageBlueprints and C++ (C++17 on UE 4.27 for modules that include NoiseGraph headers)
PlatformsWin64 and Linux (x64) only — the plugin descriptor allows exactly Win64 and Linux because the noise library ships as prebuilt binaries for those two platforms. Mac, Android and iOS are not supported. Win64 is verified by Alpha XP; Linux is supported by the code, not verified by Alpha XP.

Installation

  1. Close the editor and copy the NoiseGraph folder into your project's Plugins/ folder (create it if needed), or install the plugin from Fab into your engine.
  2. Open the project. For a C++ project, let the editor rebuild the plugin module when prompted, or build the project from your IDE.
  3. Enable NoiseGraph in Edit > Plugins (search for “NoiseGraph”) and restart the editor.
  4. C++ only: add "NoiseGraph" to PublicDependencyModuleNames in your module's .Build.cs. Add "FastNoise2" as well if you call the library API directly. On UE 4.27 set CppStandard = CppStandardVersion.Cpp17; in any module that includes NoiseGraph headers.
Verifying the install The editor loads the noise library when the module starts; if it cannot, a message box reports the library path. In a Blueprint graph, search for Make Simplex Generator under NoiseGraph.

Quick start

Blueprint

  1. Add Make Simplex Generator (category NoiseGraph|Coherent Noise).
  2. Add Make Fractal FBm Generator (NoiseGraph|Fractal), connect the simplex generator to Source and set Octaves to 5.
  3. Promote the fractal generator to a variable so it stays referenced.
  4. Call Gen Uniform Grid 2D with Start (0, 0), Size (256, 256), Frequency 0.02 and a Seed. Out Values receives 256 × 256 floats and the return value is their min/max range.
  5. Use Gen Single 2D for single samples, or Gen Tileable 2D for a seamlessly tiling texture.

C++

#include "NoiseGraphBlueprintLibrary.h"

// Keep the final generator referenced, e.g. UPROPERTY() UNoiseGraphGeneratorBase* Terrain = nullptr;
UNoiseGraphSimplexGenerator* Simplex = UNoiseGraphBlueprintLibrary::MakeSimplexGenerator();
UNoiseGraphFractalFBmGenerator* Fbm = UNoiseGraphBlueprintLibrary::MakeFractalFBmGenerator(
    Simplex, /*GainSource*/ nullptr, /*Gain*/ 0.5f, /*WeightedStrengthSource*/ nullptr,
    /*WeightedStrength*/ 0.f, /*Lacunarity*/ 2.0f, /*Octaves*/ 5);
Terrain = Fbm;

TArray<float> Heights;
const FFloatRange Range = Fbm->GenUniformGrid2D(Heights, FIntPoint(0, 0), FIntPoint(256, 256), 0.02f, 1337);
const float Single = Fbm->GenSingle2D(FVector2D(10.f, 20.f), 1337);

Generating values

Callable on every generator (UNoiseGraphGeneratorBase, category NoiseGraph). Frequency defaults to 0.01 and Seed to 1337.

NodeTypeDescription
Gen Uniform Grid 2DCallableFills Out Values with Size.X × Size.Y samples starting at Start, using Frequency and Seed; returns the min/max range.
Gen Uniform Grid 3DCallableSame for a 3D grid (Size.X × Size.Y × Size.Z values).
Gen Uniform Grid 4DCallableSame for a 4D grid; Start and Size are passed as Vector4 (components used as integers).
Gen Tileable 2DCallableFills Out Values with a seamlessly tileable 2D map of Size.X × Size.Y; returns the range.
Gen Position Array 2DCallableSamples at every 2D position of Pos Array plus Offset; returns the range.
Gen Position Array 3DCallableSamples at every 3D position of Pos Array plus Offset; returns the range.
Gen Position Array 4DCallableSamples at every 4D position of Pos Array plus Offset; returns the range.
Gen Single 2DCallableReturns one sample at a 2D location.
Gen Single 3DCallableReturns one sample at a 3D location.
Gen Single 4DCallableReturns one sample at a 4D location.

Basic generators

Static factory nodes in NoiseGraph|Basic Generators; each returns the matching generator object.

NodeTypeDescription
Make Encoded Node Tree GeneratorCallableBuilds a complete node tree from an encoded node-tree string.
Make Constant GeneratorCallableOutputs a constant value.
Make White GeneratorCallableWhite noise.
Make Checkerboard GeneratorCallableCheckerboard pattern with a cell size.
Make Sine Wave GeneratorCallableSine wave pattern with a scale.
Make Position Output GeneratorCallableOutputs the input position, multiplied and offset per axis (Vector4).
Make Distance to Point GeneratorCallableDistance from the sampled position to a point, with a distance function and per-axis scale.

Coherent noise

Static factory nodes in NoiseGraph|Coherent Noise; each returns the matching generator object.

NodeTypeDescription
Make Value GeneratorCallableValue noise.
Make Perlin GeneratorCallablePerlin (gradient) noise.
Make Simplex GeneratorCallableSimplex noise.
Make Open Simplex 2GeneratorCallableOpenSimplex2 noise.
Make Open Simplex 2SGeneratorCallableOpenSimplex2S (smooth) noise.
Make Cellular Value GeneratorCallableCellular noise returning the value of the n-th closest cell; jitter (value or source), distance function, value index.
Make Cellular Distance GeneratorCallableCellular noise returning distances; two distance indices combined by a return type.
Make Cellular Lookup GeneratorCallableCellular noise that samples a lookup generator at each cell, with a lookup frequency.

Fractals and domain warp

Static factory nodes in NoiseGraph|Fractal, NoiseGraph|Domain Warp and NoiseGraph|Fractal|Domain Warp; each returns the matching generator object.

NodeTypeDescription
Make Fractal FBm GeneratorCallableFractional Brownian motion over a source; gain (value or source), weighted strength, lacunarity, octaves.
Make Fractal Ridged GeneratorCallableRidged fractal over a source; same parameters as FBm.
Make Fractal Ping Pong GeneratorCallablePing-pong fractal over a source with a ping-pong strength (value or source).
Make Domain Warp Gradient GeneratorCallableWarps the input coordinates of a source with gradient noise; amplitude (value or source) and frequency.
Make Domain Warp Fractal Progressive GeneratorCallableFractal domain warp where each octave warps the result of the previous one.
Make Domain Warp Fractal Independant GeneratorCallableFractal domain warp where every octave warps the original coordinates.

Blends

Static factory nodes in NoiseGraph|Blends; each returns the matching generator object.

NodeTypeDescription
Add ValueCallableSource + value.
Add SourcesCallableSource + source.
Subtract ValueCallableSource - value.
Subtract SourceCallableValue - source.
Subtract SourcesCallableSource - source.
Multiply ValueCallableSource × value.
Multiply SourcesCallableSource × source.
Divide ValueCallableSource / value.
Divide SourceCallableValue / source.
Divide SourcesCallableSource / source.
Min ValueCallableMinimum of a source and a value.
Min SourcesCallableMinimum of two sources.
Max ValueCallableMaximum of a source and a value.
Max SourcesCallableMaximum of two sources.
Min Value Smooth ValueCallableSmooth minimum of a source and a value with a smoothness value.
Min Sources Smooth ValueCallableSmooth minimum of two sources with a smoothness value.
Min Value Smooth SourceCallableSmooth minimum of a source and a value with a smoothness source.
Min Sources Smooth SourceCallableSmooth minimum of two sources with a smoothness source.
Max Value Smooth ValueCallableSmooth maximum of a source and a value with a smoothness value.
Max Sources Smooth ValueCallableSmooth maximum of two sources with a smoothness value.
Max Value Smooth SourceCallableSmooth maximum of a source and a value with a smoothness source.
Max Sources Smooth SourceCallableSmooth maximum of two sources with a smoothness source.
Exponent Value Base SourceCallableBase from a source raised to a constant exponent.
Exponent Source Base ValueCallableConstant base raised to an exponent from a source.
Exponent Source Base SourceCallableBase and exponent both from sources.
Exponent IntCallableSource raised to an integer exponent.
Fade by ValueCallableFades between source A and source B by a value.
Fade by SourceCallableFades between source A and source B by a fade source.

Modifiers

Static factory nodes in NoiseGraph|Modifiers; each returns the matching generator object.

NodeTypeDescription
Domain ScaleCallableScales the input coordinates of a source uniformly.
Domain Offset by ValuesCallableOffsets the input coordinates per axis by a Vector4.
Domain Offset by SourcesCallableOffsets the input coordinates per axis by four sources (X, Y, Z, W).
Domain RotateCallableRotates the input coordinates by a rotator.
Domain Axis ScaleCallableScales the input coordinates per axis by a Vector4.
Seed OffsetCallableAdds an offset to the seed passed to the source.
RemapCallableRemaps the source output from one range to another (Vector2D ranges, default -1..1 to 0..1).
Convert RGBA8CallableConverts the source output within a range to a packed RGBA8 grey value.
TerraceCallableTerraces the source output with a multiplier and smoothness.
Add Dimension with Position ValueCallableAdds a dimension whose position is a constant value.
Add Dimension with Position SourceCallableAdds a dimension whose position comes from a source.
Remove DimensionCallableRemoves one dimension (X, Y, Z or W) before sampling the source.
Make Generator CacheCallableCaches the last result of a source that is used several times in a tree.

Generator settings

Setter nodes available on the generator objects (category NoiseGraph). Setting the matching property in Blueprint calls the same setter, which updates the live generator.

NodeTypeDescription
Set Encoded Node TreeCallableUNoiseGraphEncodedNodeTreeGenerator: Encoded node-tree string; rebuilds the tree.
Set ValueCallableUNoiseGraphConstantGenerator: Constant output value.
Set SizeCallableUNoiseGraphCheckerboardGenerator: Checkerboard cell size.
Set ScaleCallableUNoiseGraphSineWaveGenerator: Sine wave scale.
Set Data / Set Multipliers / Set OffsetsCallableUNoiseGraphPositionOutputGenerator: Per-axis multipliers and offsets.
Set Source / Set Distance Function / Set ScaleCallableUNoiseGraphDistanceToPointGenerator: Source, distance function and per-axis scale.
Set Jitter Modifier Source / Set Jitter Modifier Value / Set Distance FunctionCallableUNoiseGraphCellularValueGenerator / UNoiseGraphCellularDistanceGenerator / UNoiseGraphCellularLookupGenerator: Shared cellular settings.
Set Value IndexCallableUNoiseGraphCellularValueGenerator: Which closest cell (0-3) supplies the value.
Set Distance Index 0 / Set Distance Index 1 / Set Return TypeCallableUNoiseGraphCellularDistanceGenerator: Distance indices (0-3) and how they combine.
Set Lookup Source / Set Lookup FrequencyCallableUNoiseGraphCellularLookupGenerator: Lookup generator and its frequency.
Set Source / Set Gain Source / Set Weighted Strength Source / Set Gain Value / Set Weighted Strength Value / Set Lacunarity Value / Set Octave CountCallableUNoiseGraphFractalFBmGenerator / UNoiseGraphFractalRidgedGenerator / UNoiseGraphFractalPingPongGenerator: Shared fractal settings.
Set Ping Pong Strength Source / Set Ping Pong Strength ValueCallableUNoiseGraphFractalPingPongGenerator: Ping-pong strength.
Set Source / Set Warp Amplitude Source / Set Warp Amplitude Value / Set Warp Frequency ValueCallableUNoiseGraphDomainWarpGradientGenerator: Warp source, amplitude and frequency.
Set Domain Warp Source / Set Gain Source / Set Weighted Strength Source / Set Gain Value / Set Weighted Strength Value / Set Lacunarity Value / Set Octave CountCallableUNoiseGraphDomainWarpFractalProgressiveGenerator / UNoiseGraphDomainWarpFractalIndependantGenerator: Domain-warp generator to fractalise and fractal settings.
Set LHSSource / Set RHSSource / Set RHSValueCallableUNoiseGraphAddGenerator / UNoiseGraphMultiplyGenerator / UNoiseGraphMinGenerator / UNoiseGraphMaxGenerator / UNoiseGraphMinSmoothGenerator / UNoiseGraphMaxSmoothGenerator: Left source and right source or value.
Set LHSSource / Set LHSValue / Set RHSSource / Set RHSValueCallableUNoiseGraphSubtractGenerator / UNoiseGraphDivideGenerator: Either side can be a source or a value.
Set Smoothness Source / Set Smoothness ValueCallableUNoiseGraphMinSmoothGenerator / UNoiseGraphMaxSmoothGenerator: Smoothness of the blend.
Set Value Source / Set Value / Set Pow Source / Set PowCallableUNoiseGraphPowFloatGenerator: Base and exponent (source or value).
Set Value Source / Set PowCallableUNoiseGraphPowIntGenerator: Base source and integer exponent.
Set ASource / Set BSource / Set Fade Source / Set Fade ValueCallableUNoiseGraphFadeGenerator: Sources A and B and the fade amount.
Set Source / Set ScaleCallableUNoiseGraphDomainScaleGenerator: Source and uniform scale.
Set Source / Set Offset Sources / Set Offset ValuesCallableUNoiseGraphDomainOffsetGenerator: Source and per-axis offsets.
Set Source / Set RotationCallableUNoiseGraphDomainRotateGenerator: Source and rotation.
Set Source / Set ScaleCallableUNoiseGraphDomainAxisScaleGenerator: Source and per-axis scale (Vector4).
Set Source / Set OffsetCallableUNoiseGraphSeedOffsetGenerator: Source and seed offset.
Set Source / Set Remap from Lower Bound / Set Remap from Upper Bound / Set Remap to Lower Bound / Set Remap to Upper BoundCallableUNoiseGraphRemapGenerator: Source and remap ranges.
Set Source / Set Lower Bound / Set Upper BoundCallableUNoiseGraphConvertRGBA8Generator: Source and input range.
Set Source / Set Multiplier / Set SmoothnessCallableUNoiseGraphTerraceGenerator: Source, terrace multiplier and smoothness.
Set Source / Set New Dimension Position Source / Set New Dimension Position ValueCallableUNoiseGraphAddDimensionGenerator: Source and position of the new dimension.
Set Source / Set Dimension to RemoveCallableUNoiseGraphRemoveDimensionGenerator: Source and removed dimension.
Set SourceCallableUNoiseGraphGeneratorCacheGenerator: Source to cache.

Enums

EnumTypeValues
ENoiseGraphDistanceFunctionEnumEuclidean, Euclidean Squared, Manhattan, Hybrid, Max Axis.
ENoiseGraphCellularDistanceReturnTypeEnumIndex 0, Index 0 Add 1, Index 0 Sub 1, Index 0 Mul 1, Index 0 Div 1.
ENoiseGraphDimensionEnumX, Y, Z, W.

Troubleshooting

SymptomCause and fix
Message box “Failed to load FastNoise library at path […]” at startupThe library binary for the current platform is missing. Check that Binaries/ThirdParty/FastNoise2/Win64 (or Linux) exists in the plugin folder; packaged games stage it automatically.
The plugin is not available on Mac, Android or iOSNoiseGraph supports Win64 and Linux (x64) only; the noise library is not provided for other platforms.
C++ errors on UE 4.27 when including NoiseGraph headersAdd CppStandard = CppStandardVersion.Cpp17; to the module that includes them (inside #if !UE_5_0_OR_LATER if the module also builds on UE 5).
Crash or assertion when generating from a treeEvery source input of every node must be connected before generating; the native library does not validate missing sources. The same applies to an invalid or empty encoded node-tree string.
A generator stops working after a whileGenerators are UObjects created in the transient package. Keep the tree's last generator in a variable or UPROPERTY(); sources are held by the native tree.
Values outside -1..1Fractals, blends and modifiers can exceed the unit range. Use the range returned by the Gen nodes or add a Remap node.

Credits

© 2026 Alpha XP — alphaxp.net · Support: support@alphaxp.net. Built and verified for Unreal Engine 4.27 and 5.8.