A C++ library and interactive application for building and simulating Dynamic Neural Field architectures.
Docs · Wiki · Releases · Contributing
Dynamic Neural Fields model how neuron populations represent and transform information over continuous dimensions (position, direction, color). They produce emergent behaviours — working memory, winner-take-all selection, sequence generation — from local excitation and surround inhibition.
This library lets you design, connect, simulate, and visualize DNF architectures at runtime, either programmatically or through a visual node-graph editor. Simulations can be saved and reloaded as JSON. The application is built with real-time performance in mind, and straightforward to embed in any C++ application.
- Compose architectures in C++ — wire up fields, kernels, stimuli, and couplings in a few lines
- Visual node-graph editor — connect and reconfigure elements at runtime through an ImGui-based interface
- Real-time plots — inspect field activation, output, and input live as the simulation runs
- Save and reload — serialize any architecture to JSON and resume it later
- Embeddable — link against the library and integrate DNF simulation into any C++ application
Pre-compiled binaries are available on the Releases page. Download and run — no build tools or dependencies required. This is the quickest way to start composing and simulating DNF architectures without writing any code.
If you want to build from source, embed the library in your own project, or write custom examples, follow the steps below.
You must install the following manually:
| Platform | Requirements |
|---|---|
| Windows | Visual Studio 2022 with "Desktop development with C++" workload, Git |
| Linux | GCC 13+, CMake 3.20+, Git, OpenGL/X11 dev libraries |
| macOS | Xcode Command Line Tools, CMake 3.20+ |
Everything else — vcpkg, all library dependencies (imgui, implot, imgui-node-editor, nlohmann-json, imgui-platform-kit) — is installed automatically by the setup scripts.
Run setup once on a fresh machine, then build whenever you want to compile.
# Windows
scripts\setup.bat
scripts\build.bat
# Linux
chmod +x scripts/setup.sh scripts/build.sh
./scripts/setup.sh
./scripts/build.sh
# macOS
chmod +x scripts/setup.sh scripts/build_macos.sh
./scripts/setup.sh
./scripts/build_macos.shTo install the library for use in another CMake project:
# Windows
scripts\install.bat
# Linux / macOS
./scripts/install.shDefine a field architecture in a few lines of C++ and watch it run:
#include "application/application.h"
#include "user_interface/static_layout.h"
int main()
{
using namespace dnf_composer;
const auto simulation = std::make_shared<Simulation>("Boost detection", 10.0, 0.0, 0.0);
const auto visualization = std::make_shared<Visualization>(simulation);
const Application app{ simulation, visualization };
app.addWindow<user_interface::StaticLayoutWindow>(simulation, visualization);
// Neural field with Mexican hat kernel — local excitation, surround inhibition
const auto nf = std::make_shared<element::NeuralField>(
element::ElementCommonParameters{ "Neural field" },
element::NeuralFieldParameters{});
const auto k = std::make_shared<element::MexicanHatKernel>(
element::ElementCommonParameters{ "Mexican hat kernel" },
element::MexicanHatKernelParameters{});
const auto gs = std::make_shared<element::GaussStimulus>(
element::ElementCommonParameters{ "Gauss stimulus" },
element::GaussStimulusParameters{ 5.0, 4.0, 50.0 });
simulation->addElement(nf);
simulation->addElement(k);
simulation->addElement(gs);
nf->addInput(gs);
nf->addInput(k);
k->addInput(nf);
visualization->plot({ {nf->getUniqueName(), "activation"} });
app.init();
while (!app.hasGUIBeenClosed())
app.step();
app.close();
}More ready-to-run examples are in the examples/ folder, covering working memory, selection, sequence generation, 2D fields, Hebbian learning, and more.
| Category | Elements |
|---|---|
| Fields | NeuralField, NeuralField2d |
| Kernels | GaussKernel, MexicanHatKernel, AsymmetricGaussKernel, OscillatoryKernel (+ 2D variants) |
| Stimuli | GaussStimulus, TimedGaussStimulus, BoostStimulus, BoostStimulus2d (+ 2D variants) |
| Noise | NormalNoise, CorrelatedNormalNoise (+ 2D variants) |
| Couplings | FieldCoupling, GaussFieldCoupling |
| Memory | MemoryTrace, MemoryTrace2d |
| Resampling | Resize, Resize2d — interpolate an input field to a different spatial size (linear / nearest / cubic) |
| Dimensionality | Collapse — reduce a 2D field to 1D along an axis (sum / average / maximum / minimum); Expand — broadcast a 1D field into a 2D ridge |
Building the project produces two executables:
dnf-composer-static— a single self-contained window with all panels in a fixed layout. Best for quickly running a simulation without any setup.dnf-composer-dynamic— a fully dockable ImGui application. Windows can be rearranged, detached, and dragged to secondary monitors.
The GUI is powered by Dear ImGui, keeping it fast and lightweight.
You can also write your own launcher, link against the library, and choose exactly which windows and architectures to load. See the Wiki for a step-by-step guide.
| Project | Publication |
|---|---|
| NEAT-DNFs | NEAT-DNFs: A NeuroEvolutionary Framework for Evolving Dynamic Neural Field Architectures · GECCO 2026 · 10.1145/3795095.3805169 |
| dynamic-neural-field-degeneration | Robustness and Adaptability in a Dynamic Neural Field Architecture Subject to Degeneration · ROBOT 2025 · Springer LNNS |
| vr-hr-joint-task | Dynamic Neural Field Based Anticipatory Action Selection for Human Robot Collaboration: A Virtual Reality Experiment · ICSR + ART 2026 |
| How We Can Use Dynamic Neural Fields in Human-Robot Joint Action | How We Can Use Dynamic Neural Fields in Human-Robot Joint Action · Tessa H. Janssen · MSc thesis · TU/e |
Benchmarking against established DFT frameworks shows dynamic-neural-field-composer achieves the highest simulation throughput — delivering ~15–41% higher throughput than Cedar, the next-fastest framework — while maintaining algebraic equivalence with established implementations (and full float64 precision). The full methodology, per-size results, and cross-platform validation are available at Jgocunha/dynamic-field-theory-software.
Bug fixes, new elements, documentation improvements, and example architectures are all welcome. Open an issue before starting non-trivial work so direction can be agreed on first. See CONTRIBUTING.md for the full process.
This project is licensed under the terms in LICENSE.