Introduction
What Modeloop is, how it thinks about dynamic systems, and the three pillars every model is built on: Blocks, Signals, and the Solver.
Modeloop is a graphical environment for modeling, simulating, and analyzing dynamic systems using block diagrams. You design a system by connecting visual blocks that represent mathematical operations or physical processes, simulate its behavior over time, and generate production-grade Python and MISRA C:2012 code from the exact same model.
Modeloop runs in the browser and on the desktop, and a model behaves identically in both — what you simulate is what you ship.
A real-time data flow environment
Modeloop is built on the real-time data flow paradigm. Instead of writing imperative code that describes how to compute step by step, you describe what the system is: a network of operations connected by data. At every tick of simulated time, data flows through the network — inputs are sampled, every block computes its outputs from its inputs, and results propagate downstream.
This paradigm is the industry standard for control systems, signal processing, and embedded software, because it maps directly onto how these systems actually run on hardware: a periodic task wakes up, reads sensors, computes, writes actuators, and sleeps until the next cycle.
Every Modeloop model is built from three fundamental concepts.
The three pillars
Blocks — The Operations
Blocks are the verbs of your model. Each block encapsulates one operation — a sum, a sine, an integrator, a comparison, a lookup table — with well-defined input ports, output ports, and parameters. Blocks range from elementary math to composite structures that contain entire sub-diagrams, and up to state charts that describe event-driven logic.
You never write the implementation of a block. You configure it, connect it, and Modeloop guarantees its semantics are identical in simulation, in generated Python, and in generated C.
Signals — The Data
Signals are the nouns. A signal is a typed value that travels along a connection from one block’s output port to another block’s input port. Signals carry scalars, vectors, or matrices with explicit data types — from float64 down to uint8, booleans, and user-defined enumerations.
Because every signal is typed, Modeloop validates your model as you build it: incompatible connections are rejected at design time, not discovered at runtime.
The Solver — The Heart
The solver is what brings a model to life. Modeloop uses a fixed-step solver: simulated time advances in constant increments, and at each step every scheduled part of the model executes in a deterministic order derived from the data flow.
The solver has hierarchical capabilities. A simple model can stay a single flat diagram — you drop blocks, connect them, and simulate it directly. When a system grows, you can organize logic into tasks with independent periods and nested containers, and the solver schedules each task at its own rate, resolves execution order automatically, and keeps multi-rate systems deterministic. Structure is available when you need it, never required.
From model to product
A Modeloop model is not a drawing — it is the single source of truth for your system:
- Simulate it interactively with time-varying scenario inputs and live plots.
- Test it with portable scenarios and assertions, executed against the Python reference (MIL) or the real generated C (SIL/PIL), with coverage mapped back onto the blocks.
- Prove it: formal verification with block contracts demonstrates the absence of runtime errors — division by zero, domain violations, overflow — for all inputs, not just the tested ones.
- Generate code — clean Python for rapid iteration, and MISRA C:2012 compliant C for embedded targets — with full traceability from every generated line back to the block that produced it.
- Version and review it as text with MDL, Modeloop’s textual modeling language, which stays bidirectionally synchronized with the diagram.
Where to go next
- Quickstart — build and simulate your first model in minutes.
- Blocks, Signals, The Solver — the core concepts in depth.
- Model Hierarchy — how to structure real systems.
- Modeling Guidelines — conventions that keep large models healthy.