This comparison is published by Ionworks, the primary commercial sponsor of PyBaMM. We have aimed to represent both tools fairly based on public documentation, peer-reviewed literature, and direct product knowledge.
Both PyBaMM and GT-AutoLion implement P2D/Newman electrochemical physics at the cell level. The underlying equations are the same. Where the two tools diverge is in workflow, ecosystem, and what each is optimized for.
GT-AutoLion started life at EC Power before Gamma Technologies acquired it in April 2018 and embedded it inside GT-SUITE, the company's multi-physics system simulation platform. Battery suppliers and OEMs use it for 1D and 3D battery analysis and design, especially where the cell model needs to couple with thermal management, powertrain, or full vehicle simulation.
PyBaMM is open-source, Python-native, and focused on cell-level fidelity. Its model library spans SPM through DFN, MSMR, composite electrodes, and sodium-ion chemistries. The community is active: PyBaMM Conference 2026 was held in March 2026, and the project continues to attract both academic and industry contributors. Ionworks adds a production-grade layer on top of PyBaMM, covering automated parameterization, reproducibility, data ingestion, and code export.
The choice between them depends less on electrochemical accuracy and more on where your team works and what your deliverables are.
What each tool is
PyBaMM
PyBaMM (Python Battery Mathematical Modelling) is a free, BSD-licensed simulation framework. Its architecture cleanly separates models, spatial discretization, and solvers, which means you can swap any of these independently.
The model library is broad: SPM, SPMe, DFN, MSMR, MPM, composite electrode models, half-cell models, lead-acid, and sodium-ion DFN (confirmed October 2024). Every model is readable Python. You can inspect equations, modify submodels, or add new physics without waiting on a vendor.
The community maintains PyBaMM independently. Ionworks is the primary commercial sponsor but does not control the open-source project.
GT-AutoLion
GT-AutoLion is a commercial battery modeling module within GT-SUITE. Its P2D model has been validated in peer-reviewed work: "GT-AutoLion follows the principles of the P2D model" (Sadil et al., MDPI Batteries, 2022). A separate study describes it as offering a "complete and versatile set of models and sub-models for lithium-ion battery cell simulation" (García et al., 2023).
GT-AutoLion added solid-state battery support in 2025. The tool includes a built-in electrochemical database covering commercial cathode and anode materials across lithium-ion chemistries, and its strength is direct coupling with GT-SUITE's thermal, powertrain, and vehicle simulation capabilities.
The model implementation is closed. You configure parameters through the GT-SUITE GUI, but you cannot inspect or modify the underlying equations.
Quick reference table
| PyBaMM | GT-AutoLion | Ionworks | |
|---|---|---|---|
| License | Open-source (BSD) | Commercial (GT-SUITE) | Contact for pricing |
| Electrochemical model | SPM, SPMe, DFN, MSMR, MPM, composite | P2D / Newman (closed) | SPM, SPMe, DFN, MSMR, MPM, composite |
| Model transparency | Full, readable, modifiable | Closed, GUI-based | Full, built on PyBaMM |
| System integration | Via export (Simulink, MATLAB, C++) | Native GT-SUITE coupling | Via export (Simulink, MATLAB, C++) |
| Parameterization | Manual/Python | GUI-based, GT-SUITE only | Automated, provenance-tracked |
| Reproducibility | Depends on team infrastructure | Within GT-SUITE project files | Immutable models, logged runs |
| Web GUI | No | GT-SUITE GUI | Yes |
| 3D modeling | Supported | GT-AutoLion-3D available | Direct PyBaMM connection |
| Primary use case | Cell R&D, parameterization, degradation | Vehicle/pack simulation, drive cycle | Cell R&D with production-grade workflow |
| Cost | Free | Enterprise GT-SUITE license | Contact for pricing |
Electrochemical models
PyBaMM
PyBaMM's DFN implements the full Doyle-Fuller-Newman equations. For cases where you don't need full spatial resolution across the electrode, SPM and SPMe run in milliseconds and are often sufficient for degradation mode analysis or rapid parameter sweeps.
Beyond the standard models: composite electrode models handle graphite-silicon blends, MSMR captures multi-species, multi-reaction intercalation thermodynamics, and MPM accounts for particle-size distributions. Sodium-ion DFN support was confirmed in October 2024. Lead-acid models are also available. All models are open, extensible in Python, and published with documentation and examples.
A 2025 Wiley comparative study evaluated multiple battery simulation packages (including PyBaMM) using two different Li-ion parameter sets to assess accuracy and validity.
GT-AutoLion
GT-AutoLion's P2D implementation is well-validated in published literature. The 2023 García et al. study confirms a complete set of sub-models for lithium-ion cell simulation. Solid-state battery models arrived in 2025. The tool includes a built-in database covering many commercial chemistries.
The limitation is access. Model equations are not exposed to teams. If you need to modify a degradation submodel, add a novel reaction mechanism, or implement a chemistry not in the database, you depend on Gamma Technologies to add the capability.
Key differentiators
| PyBaMM | GT-AutoLion | Ionworks | |
|---|---|---|---|
| Model access | Full source, modify any equation | Closed, configure via GUI | Full source, built on PyBaMM |
| Chemistry scope | Li-ion, Na-ion, lead-acid, custom | Li-ion (solid-state added 2025) | Li-ion, Na-ion, lead-acid, custom |
| Model selection | SPM through DFN, MSMR, MPM | P2D (single model class) | SPM through DFN, MSMR, MPM |
| Community contributions | Open, published models added continuously | Closed, Gamma Technologies only | Builds on PyBaMM community models |
Degradation modeling
PyBaMM
PyBaMM supports coupled degradation where multiple mechanisms run simultaneously and interact: SEI growth (including on particle cracks), lithium plating (including on composite electrodes), loss of active material, lithium inventory loss, particle cracking, porosity evolution, and electrolyte depletion.
The key word is "coupled." You can run SEI growth alongside lithium plating and LAM in a single simulation, with each mechanism affecting the others. Every degradation submodel is inspectable and modifiable. Published benchmarks exist for each mechanism.
GT-AutoLion
GT-AutoLion supports chemistry-specific degradation mechanisms and predicts battery aging over a wide range of operating conditions, including calendar aging and cycle life. The acquisition announcement positions the tool for warranty lifetime prediction within GT-SUITE drive cycle simulations.
Specific mechanism-level detail is not publicly documented. For teams focused on lifetime prediction at the pack level within a vehicle simulation, this integrated approach works well. For teams doing mechanism-level degradation research, the lack of model visibility is a constraint.
Key differentiators
| PyBaMM | GT-AutoLion | Ionworks | |
|---|---|---|---|
| Mechanism transparency | Explicit, inspectable, modifiable | Closed, detail not public | Explicit, built on PyBaMM |
| Coupled mechanisms | Yes, all run simultaneously | Not documented publicly | Yes, all PyBaMM mechanisms |
| Published benchmarks | Yes, peer-reviewed | Not available publicly | Yes, PyBaMM benchmarks apply |
| Primary use | Degradation research, mechanism analysis | Warranty lifetime prediction | Degradation R&D with structured workflow |
System-level integration
GT-AutoLion (key strength)
This is where GT-AutoLion is strongest. Within GT-SUITE, the battery model couples natively to coolant circuits, HVAC systems, pack thermal distribution, powertrain components, and control system environments (MiL/SiL/HiL). No data handoff, no export step, no file format translation.
GT-RealDrive enables real drive cycle simulation for lifetime prediction. Cell, module, and pack level optimization all happen within one environment. For an OEM or Tier 1 supplier that already runs GT-SUITE for powertrain or thermal analysis, adding GT-AutoLion for battery modeling is a natural extension with minimal integration friction.
PyBaMM
PyBaMM has no native GT-SUITE integration. Cell models need to be exported before they can participate in vehicle-level simulation. Ionworks generates Simulink, MATLAB, or C++ code from parameterized cell models, and those exported models can be embedded in GT-SUITE or other system simulation environments. Python co-simulation interfaces are available for custom integrations.
The export step adds a workflow stage, but it also means PyBaMM-based models are not locked to any single system simulation platform.
Key differentiators
| PyBaMM | GT-AutoLion | Ionworks | |
|---|---|---|---|
| GT-SUITE coupling | Via export (Simulink, MATLAB, C++) | Native, no handoff | Via export (Simulink, MATLAB, C++) |
| Drive cycle simulation | Requires external tooling | GT-RealDrive integration | Requires external tooling |
| Pack/thermal co-sim | Custom Python or export | Native GT-SUITE thermal | Custom or export |
| Standalone use | Yes, no ecosystem dependency | Requires GT-SUITE license | Yes, no ecosystem dependency |
Parameterization
PyBaMM
PyBaMM uses the BPX (Battery Parameter eXchange) format, an open standard JSON schema for battery parameters. Parameterization is programmatic: Python optimization routines handle fitting, sensitivity analysis, and train/test validation. Reference parameter sets like the LG M50 O'Regan 2022 set are available as starting points.
Ionworks automates fitting to OCV, rate capability, HPPC, and half-cell teardown data. Every parameter set carries provenance metadata, so you know which data it was fitted to, when, and by whom.
GT-AutoLion
GT-AutoLion offers GUI-based parameterization within GT-SUITE. The built-in database provides material properties for a range of lithium-ion chemistries. The calibration methodology has been documented in peer-reviewed literature (García et al., 2023).
GT-AutoLion is not designed for programmatic parameter sweeps or Python-native data pipelines. If your parameterization workflow involves scripted fitting across dozens of cells with automated data ingestion, the GT-SUITE GUI becomes a bottleneck.
Key differentiators
| PyBaMM | GT-AutoLion | Ionworks | |
|---|---|---|---|
| Interface | Python, programmatic | GT-SUITE GUI | Web GUI + Python SDK + REST API |
| Parameter format | BPX (open standard JSON) | Proprietary GT-SUITE format | BPX + structured provenance |
| Sweep/optimization | Fast, CasADi/IDAKLU/JAX backends | Not designed for isolated sweeps | Automated, application-specific optimization |
| Data pipeline integration | Manual | No | Yes, Maccor, Neware, BioLogic, Arbin |
Computational performance
PyBaMM
DFN simulations run in seconds to minutes on standard hardware. SPM and SPMe complete in milliseconds. Three solver backends (CasADi, IDAKLU, JAX) cover different use cases, and OpenMP parallelization supports running many simulations concurrently. PyBaMM is designed for parameter sweeps, optimization loops, and batch processing where throughput matters.
GT-AutoLion
GT-AutoLion's solver is optimized for the system-level simulation context within GT-SUITE. Performance benchmarks for isolated cell-level sweeps are not publicly available. The tool is designed for embedded use within vehicle simulations where the cell model is one component among many, and the solver priorities reflect that.
Workflow and team access
Interface
PyBaMM requires Python fluency. For teams with strong programming skills, the startup cost is near zero (install via pip, run a notebook). For teams without Python experience, the learning curve is real.
GT-AutoLion requires GT-SUITE access. For existing GT-SUITE teams, the interface is familiar. For teams without prior GT-SUITE experience, the licensing cost and learning curve are both steep.
Ionworks adds a web GUI on top of PyBaMM, making simulation configuration, parameterization, and result review accessible to team members who don't write Python. The Python SDK and REST API remain available for engineers who prefer programmatic access.
Reproducibility
PyBaMM itself does not enforce reproducibility. If your team uses version control, virtual environments, and consistent parameter management, results will be reproducible. Many teams do this well. Many don't.
GT-AutoLion's reproducibility operates within GT-SUITE project files. For teams working entirely inside GT-SUITE, the project structure provides reasonable traceability.
Ionworks adds immutable parameterized models and logged simulation runs. Every run is recorded with its exact model version, parameter set, and input data. When a colleague asks "how did you get that result six months ago," the answer is one click away.
Licensing and cost
PyBaMM is free under a BSD license. No vendor dependency, no seat limits, no license negotiations.
GT-AutoLion requires an enterprise GT-SUITE license. Pricing is not public.
Ionworks adds the production-grade layer on top of free PyBaMM. Contact Ionworks for pricing.
When to use GT-AutoLion
GT-AutoLion is the right choice when:
- Your team already uses GT-SUITE for powertrain, thermal, or vehicle simulation
- The primary deliverable is a cell model embedded in full vehicle or pack simulation
- Battery thermal management must co-simulate with the broader vehicle thermal system natively
- Drive cycle simulation and warranty lifetime prediction are core outputs
- You do not need to modify or extend the electrochemical model itself
- You operate in an OEM or Tier 1 supplier context with existing GT-SUITE infrastructure
GT-AutoLion's value is strongest when the cell model is one part of a larger system simulation. Using it as a standalone cell R&D tool, without GT-SUITE, is not a supported workflow.
When to use PyBaMM
PyBaMM is the right choice when:
- Primary work is cell design, parameterization, or degradation analysis
- Model transparency is required: you need to inspect, modify, or extend the electrochemical model
- Programmatic workflows are needed for parameter sweeps, optimization loops, or data pipelines
- Your team is not embedded in the GT-SUITE ecosystem
- Open-source licensing is a requirement or strong preference
- Multiple chemistries or novel model formulations are in scope
As Intercalation Station noted in February 2026: "PyBaMM is an excellent open-source battery simulator ideally suited for testing the latest physics-based battery models." That assessment, from Daniel Cogswell and Andrew Weng (Volta Battery Report contributors), captures the core value well.
When teams use both
A common OEM workflow: cell modeling in PyBaMM or Ionworks, system simulation in GT-SUITE with GT-AutoLion.
Ionworks exports validated cell models as Simulink, MATLAB, or C++ code. Those exported models embed in GT-SUITE for vehicle-level integration. The cell-level source of truth lives in Ionworks, where parameterization is tracked and reproducible. The vehicle-level integration happens in GT-SUITE, where GT-AutoLion's native coupling is strongest.
This avoids maintaining two diverging cell models (one in PyBaMM and one in GT-AutoLion) that gradually drift apart as parameters get updated in one environment but not the other.
Full comparison table
| PyBaMM | GT-AutoLion | Ionworks | |
|---|---|---|---|
| License | Open-source (BSD) | Enterprise (GT-SUITE) | Contact for pricing |
| Electrochemical models | SPM, SPMe, DFN, MSMR, MPM, composite | P2D only (closed) | SPM, SPMe, DFN, MSMR, MPM, composite |
| Model transparency | Full, readable, modifiable | Closed, GUI-based | Full, built on PyBaMM |
| Degradation mechanisms | SEI, plating, LAM, LLI, cracking, depletion | Aging/capacity fade (detail not public) | Full PyBaMM degradation library |
| Thermal coupling | Lumped/distributed, customizable | Native GT-SUITE thermal integration | Lumped/distributed, customizable |
| System-level integration | Via export (Simulink, MATLAB, C++) | Native GT-SUITE coupling | Via export (Simulink, MATLAB, C++) |
| Parameterization | Manual/Python | GUI-based, GT-SUITE only | Automated, provenance-tracked |
| Reproducibility | Depends on team infrastructure | Within GT-SUITE only | Immutable models, logged runs |
| Parameter sweeps at scale | Fast, CasADi/IDAKLU/JAX | Not designed for isolated sweeps | Automated optimization |
| Web GUI | No | GT-SUITE GUI | Yes |
| 3D modeling | Supported | GT-AutoLion-3D available | Direct PyBaMM connection |
| Drive cycle simulation | Requires external tooling | GT-RealDrive integration | Requires external tooling |
| Cost | Free | GT-SUITE enterprise license | Contact for pricing |
Where Ionworks fits
Ionworks is built on PyBaMM by the team that created PyBaMM. It is the production-grade layer that addresses the gaps teams encounter when scaling PyBaMM across engineers, projects, and time.
Sections above cover the specifics. In short: Ionworks automates the parameterization workflow, ingests data from Maccor, Neware, BioLogic, and Arbin cyclers directly, makes reproducibility the default rather than the aspiration, and exports validated models as Simulink, MATLAB, or C++ code. A web GUI gives browser-based access to teams where not everyone writes Python. 3D simulations connect directly to PyBaMM, so there's no model rewrite when moving from 1D electrochemical analysis to 3D thermal-electrochemical simulation.
Ionworks is SOC2 compliant, headquartered in Pittsburgh, and was founded in 2023.
For teams evaluating GT-AutoLion without existing GT-SUITE infrastructure: book a demo with Ionworks to compare workflows directly.
For teams choosing between simulation tools more broadly: read our PyBaMM vs COMSOL comparison for the finite-element side of the decision.
Frequently asked questions
Continue reading



