# FastNoise2: SIMD Node Graphs for Procedural Noise > FastNoise2 is a C++17 library for composing Perlin, Simplex, cellular, fractal, modifier, and domain-warping operations into SIMD node graphs. It suits procedural-generation projects that need configurable noise pipelines, while FastNoise Lite remains the simpler choice for basic noise requirements. **Auburn/FastNoise2** — Modular node graph based noise generation library using SIMD, C++17 and templates - Repository: https://github.com/Auburn/FastNoise2 - Stars: 1,442 · Forks: 151 - Language: C++ - License: MIT - Published: 2026-10-16 · Updated: 2026-10-16 · Language: en - Canonical page: https://hysenlabs.com/projects/auburn-fastnoise2 ## FastNoise2's SIMD node graph design FastNoise2 addresses procedural noise pipelines that combine several generators or modifiers. Its target users are C++ developers building terrain, textures, and other procedural content, especially where a graph can be edited at runtime or exported from the included Node Editor. The library supports 2D, 3D, and 4D generation, with 2D tiling support, so it covers ordinary image-like fields and volumetric or time-dependent inputs. The central design decision is to keep a complete computation inside a node graph. A graph can contain coherent noise nodes, fractal operations, arithmetic, blending, modifiers, and domain warping. Instead of generating each noise type into separate arrays and combining them later with scalar passes, FastNoise2 expresses the operations as connected nodes and executes the combined computation through FastSIMD. Intermediate values therefore remain in SIMD registers during graph evaluation, which is the project's stated reason for fusing the work. This is more than a collection of individual noise functions. The supported coherent generators include Perlin, Simplex, SuperSimplex using OpenSimplex2S, Value, Cellular Value, Cellular Distance, and Cellular Lookup. Fractal FBm and Ridged nodes add repetition or ridge-shaped structure, while Remap, Terrace, Domain Scale, Domain Offset, and Domain Rotate alter the result. Gradient, Simplex, and SuperSimplex domain warping can be combined with fractal progressive and fractal independent modes. The graph model also creates a runtime configuration boundary. A graph can be constructed in code, encoded into a compact string, and decoded later. That makes it possible to move a complex setup from the Node Editor into an application without duplicating every generator setup as separate code. The README says the Node Editor can also connect to an application for live graph updates in an engine, although the exact integration procedure is not documented in the README itself. ## Runtime SIMD selection and supported platforms FastNoise2 uses FastSIMD to compile the same graph operations for several instruction sets and select the fastest supported level at runtime. The listed architectures are Scalar, SSE2, SSE4.1, AVX2, AVX512, NEON, and WASM SIMD. This design is useful for cross-platform software because the application can rely on a shared node model while the implementation adapts to the host CPU. The documented platforms include 32-bit and 64-bit systems, Windows, Linux, Android, MacOS on x86 and ARM, iOS, MSVC, ClangCL, GCC, and Emscripten for WASM. The support statement does not mean that every combination has identical performance. AVX2 and AVX512 are CPU-dependent choices, while NEON applies to ARM targets and WASM SIMD applies to browser or Emscripten builds. A deployment should therefore identify its architecture and compiler path before deciding which build is appropriate. Windows users face an explicit caveat. The README recommends ClangCL because MSVC has SIMD compiler bugs that can cause incorrect generation. It also states that ClangCL binaries and libraries are compatible with MSVC and that ClangCL compiles faster in the documented comparison. This recommendation is especially important for an engine project where a fast benchmark may not compensate for incorrect output. The library's benchmarking page is described as tracking each node type across commits, but the README does not explain how to reproduce those results or how graph complexity changes their interpretation. The project also separates the library from its editor. The web Node Editor runs through WASM, while compiled desktop binaries are available through the Releases page. That separation can be useful when a team wants the runtime library in an application but does not need to ship the editor. The cost is that editor integration introduces an additional tool and a serialized graph format to maintain. ## Node Editor previews and serialized graph workflows The included Node Editor is a visual front end for constructing FastNoise2 trees. It provides 2D texture and heightmap previews as well as 3D mesh previews. The README describes the generation as infinite in all dimensions. Those previews help inspect terrain-like output while changing graph structure, but they do not by themselves define how the graph will behave in a game's coordinate system, sampling pattern, or runtime pipeline. The editor can export a node tree as a serialized string. The library can load that string at runtime, which supports a workflow in which an artist or technical designer creates a graph visually and an application consumes the result. Release notes for v1.1.0 identify a Node Editor IPC C API and expanded inline documentation for public functions and classes. v1.1.1 adds Z-up mesh previewing. These are feature-level release facts, not evidence that every deployment integration is stable or documented. There is also an extension path. Custom nodes can be written through FastSIMD's SIMD-agnostic interface, after which the README says they compile for all supported SIMD architectures. Node metadata is intended to make custom nodes available to the editor, serialization, and language bindings with limited extra work. That is a meaningful benefit for projects with a house-specific noise operation, but the README does not enumerate the metadata format, binding workflow, or validation requirements. An adopting team should inspect the public headers and Wiki before committing to custom node publishing. ## Building FastNoise2 and completing a first C++ setup The repository includes `CMakeLists.txt`, `CMakePresets.json`, `include/`, `src/`, `tests/`, `tools/`, and `util/`, which confirms a CMake-based source layout with public headers, implementation files, tests, and editor-related tooling. The README's Getting Started section points readers to the project Wiki for setup details, but the README does not contain an exact clone command, configure command, build command, installation command, or first-code example. Inventing those commands would be unsafe, so the first actionable step is to open the Wiki and follow its instructions for the selected compiler and platform. For a first real use, choose the smallest graph that exercises the intended feature. A basic workflow would be to create a Perlin or Simplex node, generate a 2D field, and then add one modifier such as Domain Scale or Remap. A more representative procedural setup would connect a coherent noise node to FBm, then apply Terrace or a blend. The README confirms these node types and dimensions, but it does not show the exact C++ constructor names or method signatures. Those API details must come from the Wiki or the headers under `include/`. If the graph is authored visually instead, export its serialized string from the Node Editor and load that string through the library's documented serialization API. Confirm the output dimensions, coordinate convention, SIMD level selected at runtime, and whether the application needs 2D tiling. For a desktop editor workflow, obtain the compiled editor binary from Releases. The web editor can also be used through the README's linked WASM editor. ## Thread safety, portability, and library trade-offs FastNoise2 states that it is fully thread-safe for generating noise in parallel with the same node tree. That is useful for render systems or procedural-generation workers, but thread safety does not remove the need to determine whether the surrounding application shares output buffers or other mutable state. The README does not document cancellation, worker scheduling, allocation ownership, or error propagation, so those parts of an integration should not be inferred from the thread-safety claim. FastNoise2 is designed for performance-oriented C++17 use and SIMD optimization. Its graph abstraction is a disadvantage when the application only needs a basic coherent-noise function, because it introduces node construction and serialization concepts that FastNoise Lite does not require. FastNoise Lite is described as simpler, more portable, and better suited to basic noise needs in many languages. FastNoise2 is the better fit when SIMD throughput, richer node-based tooling, or runtime-configurable graphs are central requirements. The project supports many language bindings, including C#, Rust, Java, Unreal Engine CMake, and Unreal Engine Blueprint, but these are separate repositories. The main README does not establish that all bindings expose identical node coverage or version compatibility. Likewise, the support list names compilers and platforms without providing a compatibility matrix. A team should treat the core library and each binding as separate integration decisions. Another limitation is conceptual. A fused SIMD graph can reduce intermediate memory traffic, but it does not make every graph cheap. A graph containing multiple domain warps, fractal stages, and operators contains more work than a single noise node. The published benchmark tables cover selected 2D and 3D generators, not every possible graph composition. Their numbers should be treated as context for the architecture, not as a guarantee for a particular scene. ## FastNoise2 maintenance, licensing, and adoption boundaries The repository is not archived. Its last push was on 2026-10-14. Recent releases include v1.1.1 on 2026-02-24, v1.1.0 on 2026-02-15, and v1.0.1 on 2026-01-23. The release history shows changes to the Node Editor and public API documentation, including an IPC C API and Z-up mesh previews. It does not establish that every API will remain unchanged, so projects consuming serialized graphs should track release notes when upgrading. FastNoise2 is released under the MIT License. That identifier permits broad reuse subject to the license terms, but this article does not provide legal advice. Applications should preserve the required license and copyright notices when distributing the library or incorporated portions, and should check the repository's `LICENSE` file for the exact text. Adoption is most defensible for a C++ application that repeatedly evaluates 2D, 3D, or 4D procedural fields, benefits from SIMD, and needs graphs that artists or tools can configure without changing source code. It is less defensible for a small utility that needs one deterministic noise routine, a lightweight dependency, or a binding already covered by a simpler library. The first verification points are the Wiki build path, the public API and header requirements, the runtime SIMD selection on each target, and the serialization compatibility policy for graphs that will survive application upgrades. ## Conclusion FastNoise2 is appropriate for C++ projects that need composable, runtime-configurable procedural noise and can accept a node-based architecture. It is a poor fit when a single small noise function or broad language portability matters more than SIMD execution and graph tooling. Before adoption, verify the Wiki's build instructions for the intended platform, inspect the selected SIMD architecture on each deployment target, and confirm that the project's C++, editor, and serialization interfaces match the application. On Windows, the README specifically recommends ClangCL over MSVC because it reports SIMD compiler bugs with MSVC. ## FAQ ### What is FastNoise2 used for? FastNoise2 is a modular C++17 library for generating and transforming procedural noise, including Perlin, Simplex, cellular, fractal, and domain-warping operations. It is intended for terrain, texture, and other procedural-generation workloads that can benefit from SIMD and node graphs. ### How do I install or build FastNoise2? The README directs users to the project Wiki for getting started instructions, but it does not provide exact installation or build commands. The repository includes `CMakeLists.txt` and `CMakePresets.json`, so the Wiki and those CMake files are the appropriate starting points for platform-specific instructions. ### Does FastNoise2 support a visual node editor? Yes. The repository includes a Node Editor with 2D texture and heightmap previews and 3D mesh previews. Graphs can be exported as serialized strings and loaded by applications; the README also links to a WASM web editor and desktop binaries in Releases. ## Sources - [Auburn/FastNoise2 on GitHub](https://github.com/Auburn/FastNoise2) - [Issues](https://github.com/Auburn/FastNoise2/issues) - [License: MIT](https://github.com/Auburn/FastNoise2/blob/master/LICENSE) - [README](https://github.com/Auburn/FastNoise2/blob/master/README.md) - [Releases](https://github.com/Auburn/FastNoise2/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/auburn-fastnoise2