NeuroSim is a distributed, plugin-based simulation orchestration platform designed specifically for critical infrastructure environments. It enables organizations to model, test, and validate complex systems across operational technology (OT), SCADA networks, industrial control systems, and other mission-critical infrastructure.

Unlike traditional simulation tools, NeuroSim provides a flexible architecture that allows you to compose scenarios from independent plugins, each representing different components of your infrastructure. The platform handles coordination, message routing, state management, and observability, letting you focus on building accurate models of your systems.

Currently, NeuroSim provides an official Go SDK (github.com/NeurosimIO/neurosim-sdk-go) for building plugins. The Go SDK offers high performance, strong typing, and excellent concurrency support, making it ideal for simulation workloads.

A Python SDK is planned for future release, which will make NeuroSim accessible to data scientists and engineers who prefer Python for prototyping and analysis. Both SDKs implement the same core Plugin interface, ensuring consistent behavior across languages while leveraging each language's strengths.

NeuroSim enforces binary-level plugin isolation by running each plugin as a separate operating system process. This means plugins do not share memory, code, or runtime state. Each plugin operates independently and communicates exclusively through the Apache Kafka message backbone.

This isolation strategy provides several critical benefits: a failure in one plugin cannot crash others, plugins can be written in different languages, resource limits can be enforced per-plugin, and security boundaries are maintained at the process level. This architecture is essential for testing critical infrastructure where fault isolation is paramount.

Yes, testing SCADA and operational technology (OT) systems is a primary use case for NeuroSim. The platform was designed to address the unique challenges of industrial control systems, including protocol emulation, timing-sensitive operations, and complex state management across distributed devices.

You can build plugins that emulate PLCs, RTUs, HMIs, and other SCADA components, then orchestrate realistic scenarios to test system behavior under normal and abnormal conditions. This enables validation of control logic, security testing, operator training, and incident response planning without risking production systems.

Yes, Apache Kafka is a required component of the NeuroSim architecture. Kafka serves as the message backbone that enables communication between the orchestration engine and all plugins. Every event, command, and state update flows through Kafka topics.

Kafka was chosen for its proven reliability, horizontal scalability, message ordering guarantees, and ability to handle high-throughput workloads. The use of Kafka also enables powerful features like message replay, debugging through log inspection, and the ability to scale scenarios across multiple machines by leveraging Kafka's partitioning capabilities.

The Universal UI is NeuroSim's auto-generated configuration interface. Instead of requiring plugin developers to build custom forms and interfaces, the Universal UI automatically generates fully functional web forms based on the JSON Schema definitions provided by each plugin.

When you define your plugin's configuration schema, the Universal UI instantly provides input validation, type checking, help text, and a clean user interface—all without writing a single line of frontend code. This dramatically reduces development time and ensures a consistent experience across all plugins in the platform.

Building your first plugin starts with the Go SDK. Begin by running go get github.com/NeurosimIO/neurosim-sdk-go to install the SDK in your project. Then implement the Plugin interface, which requires defining your plugin's metadata, configuration schema, and core simulation logic.

The key methods you'll implement are: GetMetadata() to describe your plugin, GetConfigSchema() to define configuration options using JSON Schema, Initialize() to set up your plugin state, and Step() or event handlers to implement your simulation behavior. The SDK documentation includes complete examples and tutorials to guide you through the process.

NeuroSim serves industries where critical infrastructure, industrial control systems, and operational technology are central to operations. Primary industries include operational technology and SCADA environments, rail and mass transit systems, national laboratories and research facilities, manufacturing and process control, and industrial automation.

These industries share common challenges: the need to test complex distributed systems without disrupting operations, validate safety-critical behavior, train operators on realistic scenarios, and develop incident response capabilities. NeuroSim provides a unified platform for addressing these needs across diverse infrastructure environments.

NeuroSim has been proven to scale to 400+ concurrent plugin instances in production environments. The platform achieves horizontal scaling through several mechanisms: Kafka's partitioning spreads load across multiple brokers, plugins run as independent processes that can be distributed across machines, the orchestration engine itself can be scaled horizontally, and scenarios can be partitioned to run in parallel.

This architecture means you can start with a simple single-machine deployment for development and testing, then scale seamlessly to multi-node clusters for large-scale scenarios involving hundreds of simulated devices and complex infrastructure models.

NeuroSim is commercial software available under a license agreement. It is not open source. However, the SDK used to build plugins is made available to licensed users, along with comprehensive documentation, examples, and support.

This licensing model enables us to provide enterprise-grade support, regular updates, security patches, and dedicated customer success resources. Licensed organizations receive access to the full platform, including the orchestration engine, Universal UI, monitoring tools, and all SDK components needed to build and deploy plugins.

A scenario is a coordinated simulation run that involves one or more plugin instances working together to model a system or test a specific situation. When you launch a scenario, NeuroSim instantiates the configured plugins, establishes communication channels, synchronizes timing, and manages the lifecycle of the entire simulation.

Scenarios can range from simple single-plugin tests to complex multi-plugin orchestrations that model entire infrastructure environments. Each scenario has its own configuration, state management, and observability, allowing you to run multiple scenarios simultaneously or sequence them for comprehensive testing workflows.

Configuration in NeuroSim uses JSON Schema as the foundation for validation and UI generation. When you build a plugin, you define a JSON Schema that describes all configuration options your plugin accepts. This schema includes data types, validation rules, default values, descriptions, and constraints.

The platform uses this schema in two ways: first, to automatically generate the Universal UI forms where users configure plugin instances, and second, to validate configuration data before it reaches your plugin code. This ensures type safety, provides clear error messages, and eliminates the need for manual validation logic in your plugins. The result is a robust, self-documenting configuration system that scales from simple parameters to complex nested structures.