PowerIO: A Fast Parser and Converter for Power System Case Files

Samuel Talkington · June 20, 2026

I'm releasing PowerIO, a fast parser and converter for power system case files. If you've ever had to move a case from MATPOWER into PSS/E, or pull a PowerModels.jl network into pandapower, you've probably written the same kind of brittle, lossy script I have. Every tool speaks its own dialect, and the glue between them is almost always a one-off.

PowerIO is meant to be the pandoc of power system formats: read a case into one typed Network, write it back out to whatever format you need, and build the sparse matrices and graph views your solver wants along the way. The core is written in Rust, and that same engine drives the Python package, the command-line tool, a C ABI for C/C++/Julia and other FFI consumers, and PowerIO.jl. It's dual-licensed MIT/Apache-2.0.

Docs: Link Code: Link

PowerIO parses case files into a typed network model, then converts between formats and builds matrices.

Why `PowerIO`?

The design is hub-and-spoke. Every format is one reader (text → Network) and one writer (Network → text), and a conversion is just Network → Network rendered into the target schema. Adding a format touches one module instead of an N-by-N grid of pairwise converters, and everything downstream–-matrices, graphs, solvers–-sees one model.

Right now it reads and writes MATPOWER .m, PSS/E .raw (revisions 33–35), PowerWorld .aux, PowerModels.jl, egret, and pandapower JSON, PyPSA CSV folders, and GridFM Parquet. PowerWorld .pwb binary cases and GE PSLF .epc are currently read-only. Distribution networks live in a companion crate, powerio-dist, in wire coordinates: OpenDSS .dss, PowerModelsDistribution JSON, and the IEEE benchmark format.

Features

Lossless round-trips: when the reader retains the original text, writing the same format back returns it byte-for-byte. Cross-format writes are harder because schemas disagree: a field MATPOWER stores may have nowhere to go in PSS/E. PowerIO applies documented defaults and returns a warning for each field it approximates or cannot carry.
Matrices and graphs: powerio-matrix builds B', B'', the bus admittance matrix, PTDF, LODF, and adjacency directly from a parsed network, plus a graph view for connectivity work. From Python these arrive as SciPy sparse matrices and a NetworkX graph.
Normalization: to_normalized returns a copy with powers in per-unit, angles in radians, inactive elements filtered, and bus types made consistent with generator placement and the reference bus. Original source IDs are kept, so operator naming survives.
No panics: the readers are fuzzed, and every input returns an Ok or an Err. A truncated row or a malformed cost table surfaces as a structured parse error.
Small Python footprint: import powerio depends only on the interpreter. SciPy/NumPy and NetworkX are optional extras for matrices and graphs.

Quick example

import powerio as pio

case = pio.parse_file("case9.m")
print(case.n_buses, case.base_mva)        # 9 100.0

# Same-format write returns the retained original text, byte for byte
text = case.to_matpower()

# Convert, and see exactly what the target format can't represent
raw, warnings = pio.convert_file("case9.m", "psse")
for w in warnings:
    print("warning:", w)

# Matrices and graphs (with the [matrix]/[graph] extras installed)
B = case.bprime()        # scipy.sparse (also ybus, ptdf, lodf)
G = case.to_networkx()   # networkx graph

From the command line

# MATPOWER -> PSS/E
powerio convert case14.m --to psse -o case14.raw

# GE PSLF -> MATPOWER
powerio convert case.epc --from pslf --to matpower -o case.m

# Build a DC OPF bundle, or PTDF/LODF sensitivities
powerio dcopf       case30.m -o out
powerio sensitivities case30.m -o out

Performance

The priorities were correctness and predictable failure, but the Rust core is also fast: on large synthetic cases (~100k–200k buses), PowerIO parses at the same speed as ExaPowerIO.jl, whose performance work set the bar for MATPOWER parsing. Benchmarks with methodology, along with the validation suite that checks PowerIO against several reference implementations, are in the repository.

Install

cargo add powerio          # Rust

pip install powerio        # Python (parsing/conversion, no runtime deps)
pip install 'powerio[all]' # add SciPy/NumPy matrices and NetworkX graphs

Julia bindings are at PowerIO.jl.

PowerIO is a team effort in the Eigenergy group, and it leans on a lot of careful prior work documenting these formats. If you hit a format quirk or an edge case, please open an issue on GitHub.