Fact-checked by Grok 2 weeks ago

Modelica

Modelica is a non-proprietary, object-oriented, equation-based designed for modeling and simulating complex, heterogeneous physical systems, such as those in , , and multi-domain applications including mechanical, electrical, hydraulic, and thermal components. Developed by the Modelica Association, a non-profit organization based in , , it enables modeling through declarative mathematical equations that describe system behavior from first principles, without specifying the direction of . This approach facilitates the creation of reusable, modular components and libraries, supporting simulations of large-scale models with over 100,000 equations. Key features of Modelica include its support for continuous-time, discrete-time, and hybrid systems, including event handling and sampled data processing for control applications. The language uses classes as the fundamental unit for defining models, connectors, functions, and records, with mechanisms like inheritance, redeclaration, and operator overloading to promote extensibility and maintainability. It incorporates expandable connectors for graphical modeling, stream variables for bidirectional flows, and annotations for documentation, visualization, and tool-specific extensions, ensuring balanced models where the number of equations equals unknowns. Additionally, Modelica integrates algorithmic constructs such as loops and conditional statements, alongside external interfaces to languages like C and Fortran, enhancing its versatility for hardware-in-the-loop simulations and embedded systems. The development of Modelica began in 1996 as a collaborative effort to address limitations in traditional simulation languages, leading to the first specification release in 1997. Governed by the Modelica Association since 2000, the language has evolved through multiple revisions, with the current version 3.6 (as of 2025) released on March 9, 2023, introducing backward-compatible enhancements such as selective model extension, multi-language descriptions, and improved parameter and start-value handling. Earlier milestones include version 3.3 in 2012, which added synchronous elements and state machines, building on foundational work documented in standards and conference proceedings. The specification is maintained openly via GitHub, ensuring backward compatibility and community-driven improvements. Modelica's standardization promotes interoperability among tools and libraries, with the Modelica Standard Library providing pre-built components for common domains. It is implemented in commercial and open-source tools like Dymola, OpenModelica, and Wolfram SystemModeler, enabling applications in industries such as automotive, , and energy systems. By emphasizing numerical robustness, symbolic processing, and multi-domain integration, Modelica remains a cornerstone for engineering simulation, supporting efficient model exchange and collaborative development.

Overview

Definition and Purpose

Modelica is an object-oriented, declarative, equation-based language designed for the modeling of cyber-physical systems. It enables the acausal connection of components governed by mathematical equations, allowing models to be constructed from first principles without predefined computational sequences. This approach supports the development of reusable, hierarchical model libraries that can represent complex, heterogeneous systems across multiple physical domains. The primary purpose of Modelica is to facilitate the and of multi-domain systems, such as those involving , electrical, , and hydraulic components, by emphasizing and reusability. Unlike traditional imperative languages that require users to specify explicit time-stepping algorithms or causal relationships between variables, Modelica's declarative permits modelers to focus on the underlying physics through equations, with the handling the transformation into executable code. This results in more maintainable and extensible models, particularly for large-scale engineering applications. Modelica further enhances interoperability through its integration with the (FMI) standard, which allows for the export and exchange of compiled models as functional mock-up units (FMUs) between different tools and platforms. Developed and maintained by the Modelica Association, FMI complements Modelica's equation-based paradigm by enabling co-simulation and model reuse in diverse software ecosystems.

Key Characteristics

Modelica incorporates principles to facilitate the development and reuse of complex models. It supports classes such as models, blocks, functions, packages, and partial classes, enabling hierarchical structuring and modular design. allows derived classes to extend and modify base classes, promoting without duplication. Encapsulation is achieved through packages for organization and local components for parameterization, while polymorphism is realized via replaceable components that permit flexible substitutions during model instantiation. These features collectively enhance model maintainability and scalability in large-scale simulations. The language adopts a declarative , where models are expressed through mathematical equations and constraints rather than imperative algorithms or statements. This approach allows modelers to describe system behavior at a high level of , leaving the resolution of variable dependencies and computational order to the and solver. Equations can represent , algebraic, or relations, supporting symbolic manipulation and transformation into a flat hybrid differential-algebraic equation (DAE) system for efficient simulation. Modelica's multi-domain capability enables the integrated modeling of heterogeneous physical systems across disciplines like , , and . This is bolstered by extensive libraries, notably the Modelica Standard Library (MSL), which provides reusable, standardized components for domains including multi-body (e.g., ) and electrical circuits (e.g., resistors and inductors). The MSL, maintained by the Modelica Association, ensures compatibility and promotes interoperability among tools and user-contributed libraries. A core distinguishing feature is acausality, which permits equations to be written without specifying input-output or solving order. Variables are treated symmetrically, and the simulation environment simultaneously solves the entire to determine values, accommodating higher-index DAEs and avoiding the need for predefined signal flows. This contrasts with traditional causal modeling languages and aligns closely with physical principles. Hybrid modeling support allows seamless integration of continuous-time dynamics, discrete events, and finite state machines within a single framework. Continuous aspects are handled via differential equations, while discrete events are triggered using when-clauses for time or state-based conditions, enabling zero-crossing detection and event iteration. State machines are modeled through dedicated libraries like Modelica.StateGraph, which implement hierarchical, reactive behaviors for discrete-event systems. The resulting models are translated into a unified hybrid DAE representation for numerical solution. Interoperability is ensured through adherence to the Modelica Language Specification, with the latest version 3.7 (development as of November 2025) defining the syntax, semantics, and translation rules. Additionally, Modelica complies with the (FMI) standard version 3.0, facilitating model exchange and co-simulation across diverse tools via exportable FMUs (Functional Mock-up Units). This standard, released in 2022 and enhanced in subsequent updates, supports advanced features like variable communication steps and digital signatures for robust system-level .

History and Development

Origins and Early Development

The Modelica design effort originated in the fall of 1996 with the formation of an international design group, initiated by representatives from Institute of Technology, ABB Corporate Research Center in , and Daimler-Benz, among other academic and industrial partners. This group, operating initially under the ESPRIT project "Simulation in Basic Research Working Group (SiE-WG)" and later as a technical committee within Eurosim, was chaired by Hilding Elmqvist of Dynasim AB and included key contributors such as Martin Otter from the (DLR) and Peter Fritzson from . The collaboration brought together experts in language design, physical modeling, and simulation tools to address fragmented approaches in multi-domain system modeling. The primary motivations for creating Modelica stemmed from the limitations of proprietary, tools prevalent in the , which hindered model exchange and reuse across different environments. and sought a non-proprietary, equation-based that would enable seamless , support acausal modeling of complex physical systems, and facilitate the integration of models from diverse domains like , , and . This effort built on prior experiences with tools like for acausal, declarative modeling and object-oriented paradigms from languages such as and Smalltalk, aiming to unify these concepts into a standardized framework. The first draft of the Modelica specification, version 1.0, was completed in September 1997, focusing on continuous-time modeling using differential-algebraic equations (DAEs) and incorporating object-oriented features for component composition. Initial prototype implementations emerged in the late 1990s, including early tools from Dynasim AB and contributions from the design group that demonstrated practical applications, such as modeling automatic gearboxes and heat exchangers. These prototypes validated the language's potential for multi-domain simulations while highlighting needs for further refinements in discrete-event handling and library development.

Standardization and Evolution

The Modelica Association, a non-profit organization, was formed on February 5, 2000, to oversee the maintenance and evolution of the Modelica language specification, ensuring its ongoing development through collaborative efforts. This marked the transition from informal prototypes to a formalized process, with managing version releases and incorporating feedback from its members, which include academic institutions and industry partners. The standardization timeline began with the release of Modelica 1.4 in December 2000, which refined package structures for better organization of models and libraries, building on earlier informal versions from the late . Subsequent major versions introduced significant enhancements: Modelica 2.0 in January 2002 added support for initialization and graphical annotations, while Modelica 2.2 in February 2005 incorporated arrays, expandable connectors, and conditional components to improve modeling flexibility. Modelica 3.0, released in September 2007, enabled balanced models for handling overdetermined systems and introduced new operators for acausal modeling. Further evolution continued with Modelica 3.3 in May 2012 (revised July 2014), which added synchronous features and state machines while reducing restrictions on model definitions, and Modelica 3.5, approved in February 2021 with semantics finalized December 2020, which extended backward-compatible features including advanced mathematical functions and pure function refinements. Modelica 3.6, released in March 2023, focused on clarifications and enhancements such as improved exponentiation definitions and predefined type handling to support more robust implementations. As of November 2025, the development version 3.7-dev, updated November 6, 2025, emphasizes annotations for better interoperability and integration with standards like FMI (Functional Mock-up Interface). Key evolutionary milestones include the introduction of partial classes in early versions for reusable base components, refined package hierarchies in 1.4 for modular libraries, and mechanisms for overdetermined systems in 3.0 to ensure consistent balancing. These changes have progressively supported heterogeneous modeling across domains like , electrical, and systems. The of Modelica follows an open process managed by the Modelica Association, where contributions from industry (e.g., , ) and academia are reviewed via Modelica Change Proposals, ensuring transparency and broad adoption. Recent developments, discussed at the 16th International Modelica and FMI Conference in , (September 8-10, 2025), highlight enhanced support for heterogeneous models and real-time simulation capabilities in ongoing 3.7 work, alongside proposals for layered standards integrating FMI and (System Structure and Parameterization). Proceedings from the conference, published October 27, 2025, document these advancements.

Language Fundamentals

Syntax Basics

Modelica models are defined as classes using the keywords model or class, which encapsulate declarations, equations, and other elements. The basic structure begins with the keyword model or class followed by an optional identifier for the class name, then a composition section containing elements like declarations and equations, and ends with end followed by the class name if provided. For example: 
model Example
  // declarations and equations here
end Example;
This structure allows for hierarchical modeling where classes can extend others using the extends keyword to inherit components and behavior. Declarations within a model or define variables and components, scoped to the enclosing class unless specified otherwise. Variable scoping follows lexical rules, where names are looked up starting from the current class and proceeding outward to enclosing classes, respecting and protected visibility; elements are accessible from enclosing scopes, while protected ones are not. Comments are supported using // for single-line remarks, which extend to the end of the line, or /* */ for multi-line comments that do not nest. , introduced with the annotation keyword, provide such as graphical information, for example, annotation(Placement([transformation](/page/Transformation)(extent={{-10,-10},{10,10}})));. Modelica supports a range of operators for expressions. Arithmetic operators include + for , - for , * for , and / for , applicable to numerical types with multiplicative operators having higher precedence than additive ones. Logical operators are and for , or for disjunction, and not for , with not having the highest precedence among them. Relational operators encompass == for , < for less than, > for greater than, <= for less than or equal, >= for greater than or equal, and <> for , used for comparing simple types and non-associative with precedence above logical operators but below arithmetic. The equations section, delimited by the equation keyword, contains declarative equations that define relationships without specifying execution order. Equations use the = for , such as der(x) = v; to specify the of position as velocity, and are solved simultaneously by the . This section focuses on declarative forms, excluding imperative algorithm statements which are handled separately. Whitespace, including spaces, tabs, and newlines, serves as a and is otherwise ignored, allowing flexible formatting. Identifiers are case-sensitive, distinguishing Variable from variable, while keywords like model and end are case-insensitive.

Types and Declarations

Modelica employs a class-based type system where all data objects, including variables and components, are instances of classes. The language is statically typed, meaning types are determined at compile time without support for dynamic type creation or modification. This ensures type safety and enables advanced features like unit checking during modeling. The built-in types in Modelica consist of four fundamental predefined classes: Real for floating-point numbers, Integer for whole numbers, Boolean for logical values, and String for text sequences. Additionally, enumeration types allow users to define ordered sets of named literals, such as type Colors = enumeration(red, green, blue);, which can be used to represent discrete states or categories in models. These types form the foundation for all declarations and can be extended or modified as needed. Derived types build upon the built-in types through modifiers and structures. For instance, units can be attached to Real types using the unit modifier like Real distance(unit="m");, enabling dimensional consistency. Arrays are declared with subscripts, such as Real vector[3]; for a one-dimensional array or Real matrix[2,2]; for multi-dimensional ones, supporting operations like indexing and concatenation. Records provide structured types for grouping related data, declared as record Point Real x; Real y; end Point;, allowing instances like Point p; to encapsulate multiple components. User-defined types are created using the type keyword to alias or extend existing types, for example, type [Temperature](/page/Temperature) = Real(unit="K");. Replaceable types enhance modularity by allowing customization in subclasses or instances, declared as replaceable type MyType = Real;, where redeclaration can specify a different compatible type during model extension. This mechanism supports polymorphic modeling without altering the core type structure. Declarations of variables and components include variability prefixes to specify behavior: [parameter](/page/Parameter) for compile-time constants that can be modified at instantiation, as in parameter Real springConstant = 1.0;, and constant for fixed values, often combined with final to prevent redeclaration, such as final constant Real pi = 3.14159;. These prefixes control evaluation timing and mutability, with final ensuring immutability across the model hierarchy. Modelica provides built-in support for dimensional analysis through unit attributes on types, automatically performing unit checking and implicit conversions during compilation to prevent errors in physical equations. For example, adding a Real with unit "m" and another with unit "cm" triggers conversion to ensure compatibility. This feature is integral to the language's equation-based paradigm, promoting reliable multi-domain modeling. Key restrictions in Modelica's include its static nature, prohibiting runtime type changes or creation of new types dynamically, which aligns with the declarative modeling approach and facilitates efficient and . Declaration order is generally flexible, except in cases like functions where dependencies must be resolved.

Modeling Paradigms

Acausal and Equation-Based Modeling

Modelica's acausal modeling allows variables to be declared without predefined input or output designations, enabling the solver to determine causal relationships dynamically based on the system's equations. This contrasts with traditional causal languages where signal flow directions must be explicitly specified, freeing modelers to express physical laws naturally without worrying about computational order. In acausal models, all variables are treated as unknowns, and the analyzes dependencies to assign roles during preparation. The equation-based approach in Modelica represents models as systems of differential-algebraic equations (DAEs), capturing the underlying physics through declarative equations rather than procedural assignments. For instance, a simple mechanical system might be defined by equations such as [m](/page/Mass) \cdot \mathrm{der}([v](/page/Velocity)) = [F](/page/Force) for Newton's second law and \mathrm{der}([s](/page/Position)) = [v](/page/Velocity) for position-velocity relation, where [m](/page/Mass) is , [v](/page/Velocity) is , [s](/page/Position) is , and [F](/page/Force) is . These equations form a balanced system where the number of equations equals the number of unknowns, allowing symbolic manipulation to resolve the model. The resulting DAEs typically have an index of 1 to 3, depending on the physical domain, and are solved numerically using methods like DASSL or . To prepare hierarchical models for , Modelica employs a process that expands nested component structures into a single, flat set of for symbolic analysis. This involves recursive of components, of local , and resolution of , producing an acausal system without explicit hierarchies. The flattened model undergoes matching algorithms to pair with variables, identifying structural singularities if present. High-index DAEs in Modelica, common in multibody or electrical systems, require index reduction to ensure numerical solvability, typically achieved via the Pantelides algorithm. The Pantelides method systematically differentiates select equations and introduces derivative variables to lower the index to 1, using to detect dependencies. For example, in a mechanical constraint like f(x, \dot{x}) = 0, differentiation yields \frac{d}{dt} f = 0, resolving hidden constraints. This process preserves the model's physical meaning while enabling efficient integration. Modelica compilers detect and resolve over- and under-determined systems during the matching phase of , ensuring structural balance. An over-determined system, with more equations than variables, triggers redundancy analysis to identify and remove consistent duplicates or flag inconsistencies; methods propagate values to verify . Under-determined systems, with fewer equations, are flagged for constraints, prompting modelers to add parameters or equations. These diagnostics prevent errors and maintain model integrity. Hybrid modeling in Modelica integrates continuous equations with discrete algorithms to handle systems with both smooth dynamics and event-driven behaviors. Continuous equations define the ongoing evolution, while discrete algorithms, often within when-clauses, update variables at events like zero-crossings or clock ticks. At event instants, the solver resolves a mixed system of continuous residuals and discrete assignments, potentially reinitializing states to ensure seamless transitions. This synchronous approach yields deterministic hybrid DAEs, with discrete parts treated as piecewise constant between continuous integrations.

Connectors and Interfaces

In Modelica, connectors are special classes that define interfaces for interacting components, declared using the connector keyword and consisting of public variables representing physical ports or signals. These connectors enable graphical connections via the connect equation, such as connect(component1.port, component2.port), where the components must have compatible structures with matching named elements and dimensions. For instance, an electrical pin connector might be defined as: 
connector Pin
  Real v;
  flow Real i;
end Pin;
This declaration includes a potential variable v for voltage and a flow variable i for current. Flow variables, marked with the flow prefix, represent conserved quantities like electrical current or mechanical force, following the convention that their sum across a connection equals zero to enforce physical balance. Non-flow (potential) variables, such as voltage or , are instead equated across connections, ensuring without directional flow. When components are connected, Modelica automatically generates balance equations: for flow variables, the equation is z_1 + z_2 + (-z_3) + \dots + z_n = 0, where signs depend on the connector's inside/outside orientation; for potential variables, it is a_1 = a_2 = \dots = a_n. This mechanism ensures conservation laws are upheld implicitly during simulation. Expandable connectors, qualified with the expandable keyword, allow dynamic augmentation with additional undeclared variables at connection time, facilitating flexible interfaces like buses. For example, connecting connect(bus.speed, sensor.speed) to an expandable EngineBus connector adds a speed variable if not previously defined, enabling hierarchical signal aggregation without rigid predefined structures. Non-expandable connectors, in contrast, require exact matches of all elements for compatibility. Connections in Modelica are inherently acausal, lacking predefined directionality, which allows bidirectional interactions based solely on variable types and balance rules rather than input/output causality. This design supports multi-domain modeling where the solver determines flow directions dynamically, as in connect(load.p, ground.p) for an electrical circuit, equating potentials and summing flows without assuming a source-sink orientation. For non-physical data exchange, such as control signals, Modelica supports signal connectors using input and output prefixes to impose causality, treating them as directed streams rather than conserved flows. An example is a RealInput speed connector, where connect(source.speed, receiver.speed) propagates the value unidirectionally from output to input, suitable for discrete or event-based interactions outside physical domains.

Component Hierarchies and Composition

In Modelica, components are instantiated within a class through declarations that specify the component's type and optional modifiers to customize its properties. For instance, a resistor component can be declared as Resistor R(R=10);, where Resistor is the class type, R is the instance name, and R=10 is a modifier setting the resistance parameter to 10 ohms. This instantiation process generates an object from the class definition, allowing reuse of predefined models while tailoring them to specific contexts. Component declarations support arrays, conditional inclusion via parameters, and structured types, enabling the composition of complex systems from simpler building blocks. Hierarchies in Modelica are constructed through nested es, where components can contain other instances, fostering modular and scalable model structures. Modifications allow overriding of default values during or , such as R(R=20) to adjust a nested resistor's without altering the base . Redeclarations, marked by the replaceable in the base , permit replacing entire component types or packages in derived models, enhancing flexibility in ; for example, redeclare Real x changes a component's type while preserving its role. These mechanisms support deep nesting, where inner declarations can be modified from outer scopes, promoting reuse across model levels. Inheritance is achieved using the extends keyword, which incorporates all public and protected elements from a base class into a derived one, allowing while inheriting behavior. A derived class can override non-final components from the base, such as redefining parameters or equations, and supports from several base classes, provided name conflicts are resolved. This object-oriented approach enables the creation of extensible model families, where base classes define common interfaces and derived classes add domain-specific details. Packages serve as containers for organizing libraries of classes, functions, and subpackages, facilitating hierarchical structuring of reusable components. For example, the standard Modelica.Mechanics package contains subpackages like Rotational and Translational, allowing users to import and compose mechanical models systematically via clauses such as import Modelica.Mechanics;. Packages can inherit from other packages, ensuring consistent organization, and use protected elements for to maintain clean interfaces. Modifiers propagate through hierarchies during and , with outer modifications taking precedence over inner defaults to ensure consistent parameterization. The each keyword applies modifiers uniformly to array elements, as in Resistor R[2](each R=10);, streamlining the configuration of repeated components. This propagation mechanism supports balanced models by aligning parameters across nested levels without manual repetition. Partial models act as abstract templates that cannot be directly instantiated but serve as bases for specialization through extension. Declared with the partial prefix, such as partial model Base, they define shared structure and equations for subclasses, promoting reuse in library development; for instance, a partial lumped volume model might specify common thermodynamic parameters without concrete values. Derived models extend these to add specific implementations, ensuring and avoiding in hierarchical compositions.

Examples

Basic Types and Components

Modelica provides several predefined basic types for modeling, including Real for continuous real-valued quantities, [Integer](/page/Integer) for whole numbers, [String](/page/String) for text, and [Boolean](/page/Boolean) for logical values. These types form the foundation for declaring variables and parameters within models, enabling the representation of physical quantities and constants. For instance, a simple model can declare a Real variable with an initial value and a parameter for a fixed coefficient, as shown below. 
modelica
model Simple
  Real x(start=0);
  parameter Real a = 1;
equation
  der(x) = a;
end Simple;
In this example, x is a continuous-time variable initialized to 0, while a is a tunable parameter that remains constant during simulation. The equation defines the derivative of x as equal to a, modeling a basic linear integrator. Such declarations follow the general syntax for components, where variability prefixes like parameter distinguish constants from dynamic variables. Users can extend the basic types by deriving custom types, often incorporating attributes such as units for dimensional consistency. A common practice is to define a type for electrical potential as follows: 
modelica
type Voltage = Real(unit="V");
This user-defined type inherits all properties of Real but adds a unit annotation, facilitating unit checking and documentation in larger models. Derived types promote reusability and clarity, especially in domain-specific libraries. A practical reusable component built from these types is a basic model, which relates voltage, charge, and current through fundamental equations. The model declares as a and uses Real variables for state and inputs: 
modelica
model Capacitor
  parameter Real C = 1 "[Capacitance](/page/Capacitance) (Farad)";
  Real v "Voltage across capacitor";
  Real q(start=0) "Charge stored";
  input Real i "Current through capacitor";
equation
  C * v = q;
  der(q) = i;
end Capacitor;
Here, the equations enforce the constitutive relation C \cdot v = q and the dynamic charge accumulation \frac{dq}{dt} = i, using built-in Real types without external dependencies. This component can be instantiated in simulations to represent electrical storage elements. To simulate such models, initial conditions are specified via the start attribute in variable declarations, ensuring a well-posed initial value problem for the solver. Conceptually, a tool translates the model equations into a system of differential-algebraic equations, then invokes a numerical solver (e.g., DAE solver) over a specified time interval, such as from 0 to 10 seconds, with adjustable tolerances. No explicit invocation syntax exists in the language itself, as this is handled by the simulation environment. Post-simulation, the results include time-series data for variables like x or q. Tools typically generate output files or in-memory results, allowing users to plot variables against time—for example, visualizing x as a in the Simple model or v versus q in the Capacitor—to analyze system behavior and validate the model. Annotations can guide plot configurations, but core output relies on the simulated variable values.

Physical System Interactions

Modelica enables the modeling of physical interactions between components through that define interfaces for effort and variables, allowing seamless of models across domains. A fundamental example is an comprising a and a . The basic , Pin, declares a potential v for voltage and a i for , with the attribute ensuring conservation laws are applied at connections. The resistor component implements Ohm's law acausally, relating voltage across its terminals to current through it. The model is defined as follows: 
modelica
model Resistor "Ideal linear electrical resistor"
  import Modelica.SIunits;
  parameter SI.Resistance R(start=1) "Resistance at temperature T_ref";
  parameter SI.Temperature T_ref=300.15 "Reference temperature";
  parameter SI.LinearTemperatureCoefficient alpha=0 
    "Temperature coefficient of resistance";
  extends Modelica.Electrical.Analog.Interfaces.OnePort;
  extends Modelica.Electrical.Analog.Interfaces.ConditionalHeatPort(T = T_ref);
  SI.Resistance R_actual "Actual resistance";
equation 
  R_actual = R*(1 + alpha*(T_heatPort - T_ref));
  v = R_actual * i;
  LossPower = v * i;
end Resistor;
To form a complete , instantiate the and a constant , connecting them via Pin interfaces and grounding the negative terminals. The connections implicitly enforce Kirchhoff's current law (KCL) through the flow variable i, as the solver generates equations summing currents to zero at each ; similarly, Kirchhoff's voltage law (KVL) arises from the potential variable v equating voltages around loops. For multi-domain interactions, consider a direct current (DC) motor where electrical and mechanical systems couple via an electromotive force (EMF) component. The electrical side includes a , , and connected to the motor's electrical pins, while the mechanical side features a rotational attached to the motor's rotational flange connector rotFlange. The EMF model translates electrical power (voltage times current) into mechanical on the , with the flange defining as potential and as flow. A sample model connects these as: 
modelica
model DCMotorCircuit
  Modelica.Electrical.Analog.Basic.[Resistor](/page/Resistor) resistor1(R=10);
  Modelica.Electrical.Analog.Basic.[Inductor](/page/Inductor) inductor1(L=0.2);
  Modelica.Electrical.Analog.Basic.[Ground](/page/Ground) ground1;
  Modelica.Mechanics.Rotational.Components.[Inertia](/page/Inertia) inertia1(J=1);
  Modelica.Electrical.Machines.BasicMachines.Components.DCMachines.DCM_ElectricalExcitation emf1;
  Modelica.Blocks.Sources.Step step1(height=12);
  Modelica.Electrical.Analog.Sources.SignalVoltage signalVoltage1;
equation
  connect(step1.y, signalVoltage1.v);
  connect(signalVoltage1.p, resistor1.p);
  connect(resistor1.n, inductor1.p);
  connect(inductor1.n, emf1.pin_p);
  connect(emf1.pin_n, ground1.p);
  connect(signalVoltage1.n, ground1.p);
  connect(emf1.flange, inertia1.flange_a);
end DCMotorCircuit;
This setup simulates the motor accelerating under applied voltage, demonstrating energy transfer from electrical to mechanical domains. Event handling in interactive models, such as a simple electrical switch, utilizes clauses to detect and respond to discrete events like state changes. A basic switch model might monitor time or a signal to toggle between open and closed states, reinitializing variables if needed to maintain . For instance, the switch could use a condition based on time exceeding a to activate, combined with conditional equations for conductance. This approach allows modeling where continuous pause at events for discrete updates, preventing numerical issues in . Simulating the voltage source-resistor circuit with a 10 V source and 1 Ω resistor yields a steady-state current of 10 A, as determined by i = \frac{V}{R}, with the solver resolving the acausal equations to balance flows at connections. In the DC motor example, the rotational speed reaches equilibrium based on load inertia and electrical parameters, typically stabilizing after transient buildup.

Hierarchical Model Building

Hierarchical model building in Modelica enables the composition of complex systems by nesting components within higher-level models, leveraging and to promote reusability and . This approach allows modelers to construct intricate simulations, such as electrical circuits or mechanical assemblies, by assembling predefined classes while customizing behaviors at each level. For instance, a base model can define common structure, which is then extended or instantiated with specific parameters to form larger systems. A practical example is constructing a full electrical circuit from sub-components. Consider a model for a simple resistor network: 
modelica
model ResistorCircuit  
  import Modelica.Electrical.Analog.Basic;  
  Basic.Resistor R1(R=100);  
  Basic.Resistor R2(R=200);  
  Basic.Resistor R3(R=300);  
  Basic.Ground ground;  
equation  
  connect(R1.p, R2.p);  
  connect(R1.p, R3.p);  
  connect(R2.n, ground.p);  
  connect(R3.n, ground.p);  
end ResistorCircuit;
This hierarchical model instantiates resistors from the library and connects them to simulate voltage division, demonstrating how sub-components form a cohesive circuit without rewriting low-level equations. Customization occurs through parameter modification in instances, allowing tailored behavior within hierarchies. In the above circuit, an instance might override values, such as ResistorCircuit myCircuit(R1(R=50)), which adjusts R1's resistance while retaining the structural connections. This flexibility supports scenario-specific adaptations, like varying component values for sensitivity analysis, without altering the base model definition. Library usage facilitates integration of validated components, such as those from the Modelica Standard Library (MSL). For systems, models can springs or inductors; for example, a damped oscillator might instantiate Modelica.Mechanics.Rotational.Components.[Spring](/page/Spring) and Damper within a rotational , connected via flanges to simulate oscillatory motion. This draws on the hierarchical structure of MSL packages like Modelica.[Mechanics](/page/Mechanics).MultiBody.Parts for elements, enabling rapid assembly of physical subsystems. Redeclaration allows swapping component types in hierarchies to explore variations. In an electrical-thermal model like TemperatureElectricalCircuit, resistors can be redeclared as temperature-dependent variants: 
modelica
model TemperatureElectricalCircuit  
  parameter Modelica.SIunits.Temperature Temp = 300.15;  
  extends BaseCircuit(redeclare Modelica.Electrical.Analog.Semiconductors.TempResistor R1(RT=0.1, Temp=Temp));  
  // connections inherited from BaseCircuit  
end TemperatureElectricalCircuit;
This replaces standard resistors with TempResistor instances, altering resistance based on temperature while preserving the overall circuit topology. During simulation, hierarchical models are flattened into a single set of s for efficient numerical solution. For a multi-body , such as a racing car model composed of , suspensions, and wheels using MSL components like revolute joints and springs, flattening yields a differential-algebraic () with approximately 30 states and 6,500 algebraic variables from an original structure of 73 bodies and 92 joints. This process, handled by tools like , enables accurate of the vehicle's motion under forces, illustrating the of hierarchical composition.

Implementations

Compilers and Simulators

Modelica models are compiled and simulated using specialized tools that translate declarative, equation-based descriptions into executable code, enabling the solution of differential-algebraic (DAE) systems. These tools handle the complexities of acausal modeling by performing manipulations to generate efficient numerical solvers, supporting both open-source and commercial implementations. As of November 2025, the ecosystem includes robust options for large-scale simulations, with ongoing advancements in and capabilities. The primary open-source compiler and simulator is , developed by the Open Source Modelica Consortium (version 1.25.5 as of October 2025), which provides a complete environment for , compiling, and simulating Modelica models compliant with the latest language specifications, including Modelica Standard Library (MSL) version 4.1.0. Its OpenModelica Compiler (OMC) features a modular with a frontend for and , a backend for symbolic manipulation and optimization, and to C for execution via integrated DAE solvers. Active development in 2025 has introduced enhancements such as improved parallel for faster simulations of complex systems, as demonstrated in recent workshops. Commercial tools offer advanced features tailored to industrial applications. (version 2025x as of November 2025), from , excels in multi-body dynamics simulations and includes strong symbolic processing for efficient in , supporting execution and handling of large hierarchical models. MapleSim (version 2025 as of June 2025), developed by Maplesoft, leverages symbolic computation for equation analysis and , enabling customized model reduction and high-fidelity multi-domain simulations with seamless integration. SimulationX (version 2025 as of September 2025), by ITI (part of ), provides a graphically interactive for multi-physics modeling, with a that generates code for analysis across 1D to domains. The compilation process in Modelica tools typically involves several stages to transform high-level models into simulatable forms. It begins with the Modelica to build a of classes, components, and equations, followed by and to resolve hierarchies into a single set of equations. Symbolic manipulation then indexes variables, sorts equations, and performs tearing to reduce the DAE system, often generating matrices for efficient solving. Code generation produces C or executables, which are linked to numerical integrators like DASSL or for time-stepping simulation of the resulting or DAE systems. This process ensures scalability, though large models may require optimizations like handling to manage computational demands. Interoperability is facilitated through the (FMI) standard, which allows Modelica tools to export models as Functional Mock-up Units (FMUs) for co-simulation or model exchange, independent of the originating tool. All major Modelica compilers, including , Dymola, MapleSim, and SimulationX, support FMI 2.0 and 3.0 for importing and exporting FMUs, enabling seamless integration with non-Modelica environments for hybrid simulations. This capability has been pivotal for distributed system modeling since FMI's inception under the Modelica Association. Performance considerations focus on managing large-scale models and enabling real-time applications. Tools like and employ advanced techniques such as dynamic tearing and parallel solving to simulate models with thousands of equations, achieving speeds up to 500 times faster than for building energy systems. capabilities are supported through fixed-step solvers and code optimizations, as seen in chassis and powertrain benchmarks running on embedded hardware without overruns. For very large models, sparse linear algebra and event reduction further enhance efficiency, though challenges persist in highly nonlinear systems requiring careful model structuring.

Development Environments

Development environments for Modelica provide integrated graphical and textual interfaces that facilitate the authoring, , , and of complex models, enabling engineers to leverage the language's acausal and object-oriented capabilities without deep manual coding. These tools typically include editors for component-based , simulation orchestration, and result analysis, supporting both novice users through drag-and-drop workflows and experts via advanced scripting integration. Popular environments such as OMEdit, , and Wolfram SystemModeler (version 14.3 as of August 2025) dominate the ecosystem, each offering tailored features for industrial and research applications while ensuring compatibility with Modelica standards. OMEdit, the for , serves as an open-source development environment with comprehensive support for model creation, browsing, and . It features a graphical editor for drag-and-drop assembly of components into hierarchical diagrams, a library for navigating and instantiating pre-built models, controls for setup and execution, and built-in plotting tools for visualizing results in real-time or post-. OMEdit also supports textual of Modelica code alongside graphical views, allowing seamless switching between paradigms for debugging and refinement. Dymola offers a commercial development environment optimized for efficient and in Modelica, emphasizing user productivity in multi-domain systems. Its includes drag-and-drop modeling for rapid component connection and construction, capabilities for visualizing dynamic behaviors in and electrical systems, and integrated optimization tools for parameter tuning and design space exploration. These features enable iterative workflows where models can be tested, refined, and exported directly within the environment, supporting advanced post-processing like . Wolfram SystemModeler integrates Modelica modeling with the symbolic computation power of , providing a unified platform for both and analytical insights. Users can build models using a drag-and-drop for component placement and , then leverage Mathematica's tools for symbolic analysis, such as of equations or derivation of analytical solutions for steady-state conditions. This tight allows for hybrid numerical-symbolic workflows, where results can be automatically processed for optimization or design without leaving the environment. Common features across Modelica development environments enhance usability and collaboration, including for code readability, autocompletion for keywords, classes, and components to reduce errors, version control integration with systems like for tracking model evolutions, and graphical diagram editing with zoom, pan, and icon customization. These elements streamline the development process, from initial sketching to deployment, while maintaining Modelica's emphasis on reusable, modular designs. Extensibility in Modelica environments is achieved through plugins for adding custom functionalities, such as specialized or export formats, and support for user-defined libraries that extend core Modelica packages. Handling of the (FMI) is a key aspect, allowing seamless import and export of models as FMUs for co-simulation across tools, ensuring in heterogeneous workflows without recompilation.

Applications and Use Cases

Industrial Domains

Modelica has found extensive application in the for simulating and systems, enabling engineers to model complex interactions such as drivability and handling characteristics. For instance, at , Modelica-based tools like are employed for simulations and active safety system development, allowing for the integration of multi-domain models that facilitate early-stage design validation. Similarly, utilizes Modelica and the (FMI) standard to streamline model integration in and vehicle system development, reducing efforts in combining components from different domains. In the aerospace sector, supports the modeling of flight systems and management for , particularly in hybrid-electric propulsion architectures. has applied Modelica to develop flexible model architectures for the X-57 electric demonstrator, simulating distributed propulsion effects and supporting certification processes through multi-physics . This approach allows for the hierarchical modeling of aero-propulsion systems, enabling rapid evaluation of strategies and behaviors in environments. The leverages Modelica for simulating power plants and HVAC systems, optimizing in multi-energy setups. ABB employs Modelica in its OPTIMAX PowerFit for of virtual power plants, integrating diverse sources to enhance system flexibility and thermodynamic performance. In HVAC applications, the Modelica Buildings library provides dynamic models for building systems, supporting simulations of and cooling to reduce operational costs. For power plants, Modelica models of combined-cycle systems aid in transient analysis and tuning, as demonstrated in simulations of operations. In , Modelica is used for and , enabling accurate simulations of manipulators and lines. Delta robots, common in high-speed tasks, have been modeled and controlled using Modelica to handle dynamic trajectories and impedance adjustments, improving precision in pick-and-place operations. For , Modelica implementations of the Tennessee Eastman benchmark facilitate plant-wide monitoring and fault detection, supporting scalable simulations of chemical workflows. A notable involves Modelica in modeling, where second-order models simulate cell dynamics under varying loads, achieving high accuracy for thermal management and state-of-charge estimation in automotive applications. Another example is optimization, where Modelica-AeroDyn frameworks enable dynamic simulations of floating s and multi-rotor configurations. The adoption of Modelica in these domains yields key benefits, including reduced prototyping time through object-oriented model reuse and rapid integration of multi-physics components, which cuts development cycles by allowing domain experts to collaborate efficiently without . This multi-physics capability supports seamless simulation of coupled phenomena like , electrical, and interactions, leading to more robust industrial designs and up to 40% reductions in computational time for large-scale models.

Research and Education

Modelica plays a significant role in academic research, particularly through extensions that enhance its capabilities in systems and integration. For systems, the DEVSLib provides a for modeling hybrid discrete-event and continuous systems using Modelica's object-oriented , enabling multi-domain simulations of complex architectures. Recent advancements include hybrid approaches, such as FMI-based trajectory planning for satellite , which combine Modelica models with learning algorithms to optimize in dynamic environments. In , hybrid models blending physical equations from Modelica with trainable neural components have emerged by 2025, exemplified by the SMArtInt+ that facilitates integration for improved simulation accuracy in applications like . In education, Modelica supports curricula at universities, with tools like enabling hands-on student projects in . At , Modelica-based environments such as are integrated into master-level courses on embedded control systems, allowing students to design and simulate multi-domain models. 's open-source nature facilitates theses and projects, including translators from to Modelica for type-inferred modeling tasks. These applications emphasize practical learning of equation-based modeling for engineering disciplines. The Modelica community fosters research and education through annual conferences, user groups, and open libraries. The International Modelica Conference, held yearly, convenes researchers and educators; the 2025 edition in , , featured sessions on AI-Modelica hybrids and scalable simulations. Regional user groups, such as the North American Modelica Users Group (NAMUG), organize events and collaborations to advance pedagogical and research applications. Open libraries, hosted by the Modelica Association, provide reusable components across domains, supporting community-driven extensions. Community contributions extend Modelica to custom domains like and via user-developed libraries. The Physiolibrary offers open-source models for human physiology simulations, including cardiovascular and respiratory systems, enabling research in . For and social systems, the BusinessSimulation library models dynamical processes in and , such as stock-flow diagrams for . These libraries demonstrate Modelica's adaptability beyond traditional . Key challenges addressed in research and education include teaching acausality and developing scalable solvers. Acausality, a core Modelica feature allowing bidirectional variable flows without predefined inputs/outputs, is taught through tutorials emphasizing reusable components and equation-based over causal assignments. Research on scalable solvers tackles large-scale models, with techniques like sparse and array-preserving methods enabling simulations of systems up to one million equations, as in power grid analyses. Future directions in Modelica research explore deeper integration, such as zero-shot parameter estimation using transformer-based networks for rapid model calibration in building simulations, and potential interfaces for emerging paradigms like quantum-enhanced computations, building on current trends.