Open software for OverHead Lines

OpenOHL

Overhead power lines, designed in the open.

Two applications on one engine: OHL-Design for the line (sag and tension, clearances, line layout, drawings) and OHL-Structure for pylons and their loading, with the ohl command line beside them. Written in Rust, free under MPL‑2.0, in pre-alpha.

Pre-alpha and in active development: no feature is finished or approved yet. Every result must be verified by a qualified engineer.

Get OpenOHL See how it works
Illustration: lattice pylons carrying three-phase wires across hilly ground, with a field of survey points

OHL-Design

In active development

The whole line,
in one window.

3D, plan and profile views share one selection and one weather case. Click a span and its cable, circuit, system and the sag and tension of every weather case are right there.

The OHL-Design window with Testland, an invented test line: layers on the left; in the middle a 3D view of a double-circuit line crossing a valley with a river, a smaller line passing beneath the long span, and the hotbar of tool icons; below it the profile of the whole route from T1 to T13; on the right the properties of the selected structure T6 with its type, position, wire points and the spans it carries.
Testland, an invented test line (every name, place and coordinate made up). Rendered headless by the application's own test harness.

In active development

From a route
to a drawing set.

Every step is a command applied through the project session, so it can be undone, logged, shared and solved again: only the sections an edit touches are re-solved, with the same result as a full solve.

  1. 01

    Route and alignments

    Several alignments per line, with stationing, offsets and line angles. Structures can be shared between routes, for Y-pylons or parallel routes that rejoin.

  2. 02

    Structures

    Pylons from a library of types, one .ohls file each, chosen in a structure picker with a preview and placed by position, angle and height adjustment. The Replace structure tool puts another type in a structure's place and rewires its wires, asking where wire points do not match.

  3. 03

    Strings and wiring

    Suspension, V- and strain strings; sections strung through them with a cable, circuit, electrical system and bundle; jumpers at dead-ends and taps.

  4. 04

    Sag and tension

    Exact catenary, change of state, ruling span or exact equal-H sections, non-linear stress-strain and creep, solved in 3D over every weather case.

  5. 05

    Clearances

    Vertical and radial, to the ground, to LiDAR classes, to other lines and other wires, by voltage, with the wind applied in steps.

  6. 06

    Loads and structures

    Load cases, design-code plugins, loads at every attachment point, allowable spans and load trees; each placed structure's loads handed to OHL-Structure for its finite-element analysis.

  7. 07

    Drawings and exports

    Plan and profile sheets as SVG, DXF, PDF and PNG; profile exports; exchange through OHL XML, the open XML schema of the line, LandXML, GeoJSON, IFC, KML and more.

In active development

Three views.
One selection.

Dockable pages that stay in step: pick a structure in the plan and the 3D view, the profile and the properties follow. Change the weather case and every wire is redrawn.

Testland, an invented test line, drawn by electrical system: in the 3D view the two circuits of the main line and the branch at a junction tower carry their system colours and line codes, solid and dash-dot; the profile below shows direction arrows along the wires.
Wires coloured by circuit and system, with line codes and direction arrows in 3D and in the profile.

3D that streams

A wgpu renderer streams terrain, LiDAR, structures and wires in and out by distance, with three levels of detail per layer and a point budget for the survey.

Plan and profile

Straightened plan and profile per route, orthophotos and DXF drawings as backgrounds, alignment points edited where you see them.

Live while you edit

Move a structure and the shown case re-solves the touched sections as the values change. One command on Apply, one step of undo.

OHL-Structure

In active development

As much pylon
as you have.

The structure application edits one structure file in a window of its own: x to the right of the line, y ahead, z up. Start it with Edit on a structure in OHL-Design, or open a file on its own. Its detail level is worked out from what the file holds, and rises as you fill it in.

Level 3, full design: every member with a section and material, and the supported joints at the feetL90×9L120×12pinned

Full design

Every member with a section and a material, and supported joints; for a pole, its material and wall. Members can be truss, frame, cable or tension-only.

For finite-element analysis and for export. Member usage uses Euler buckling; design-code checks of members and joints are planned.

Body generators

Legs and panels (single diagonal, X, K, diamond or Warren bracing), crossarms, a peak, a face copied. The file keeps each generator's inputs, so it can be rebuilt without touching what was made by hand.

Poles and extensions

A pole's outline by height, round or polygonal, with its material and wall. Extension pieces and longer legs, taken into the finite-element model of a placed structure that uses them.

Loads per placed structure

OHL-Design computes the forces at each placed structure; load-case recipes say which value, factor and share go on which points or members, wind on members included. A case in which a wire did not solve is marked incomplete, never a pass.

Finite elements

Truss, frame, cable and tension-only members, first order or P-Delta. Joints that no member stiffens in a direction are held and reported; a real mechanism is named with the joints that move. Per-member capacities, effective lengths, angle orientation and a dead-load factor.

Section library

Profiles and materials in .ohlsec files, referred to by id, with their computed properties and the widths that take the wind.

Exports

A level-3 structure as IFC4, IFC2x3, SAF (xlsx) or CSV tables, with sections and supports, and load cases in IFC4, SAF and CSV. Imports into other programs have not been tried yet.

Planned: code checks of members and joints as plugins, structures and line solved together, clearances to the structure body, level 2 and 3 members on the drawing sheets.

In active development

Every span.
Every case. Every gust.

Rules name a target and the distance to keep. OHL-Design checks each span against them and tells you the lowest clearance, where it is, and which weather case governs it.

Illustration: a span over ground and trees. On the left, the profile with the vertical clearance under the wire; on the right, a cross-section where the wire swings out in wind steps and the radial distance to the nearest tree point is measured.verticalProfileCross-section, wind in stepsradial0 → case

Vertical and radial

Straight under the wire, in a zone with a width and depth you set, or the direct 3D distance. Bundles are checked to the nearest subconductor.

Wind in steps

Instead of only the case's full pressure, every pressure from zero up to it, in steps such as 50 Pa, on both sides or one.

To the survey

Ground surfaces, LiDAR classes picked from the point cloud, other lines and other wires of the same line. Requirements by voltage, as tables or formulas.

Also: envelopes over several weather cases, case pairs between wires, exclusion zones near clamps, galloping ellipses, blowout against the right of way, and vegetation encroachment with growth and fall-in. The clearance windows can load presets that a design-code plugin provides (the plugins in the public code provide none yet), and ohl zones runs the same check without a window.

The project in numbers

Validation cases with reference values
67
Rust crates in the workspace
36
Design-code plugins in the public code
6
Applications on one engine, plus the command line
2

Counted in the repository in October 2026. Each validation case compares a calculation with a reference value within a stated tolerance. Design-code plugins take every value from your parameter file; no code tables are shipped.

Engineering

In active development

Open numbers,
all the way down.

Every calculation is open, documented in the theory manual and traced to its reference. Checks run on demand and never change the model.

Wires

Finite-element wire systems with exact catenary elements: suspension, V- and strain strings, bundles, jumpers, 3D blowout, broken spans, point and distributed loads.

Loads

Load cases from weather, load factors and wire condition. Plugins that implement the methods of NESC, CSA C22.3, IEC 60826, EN 50341, ASCE MOP 74 and GO 95, with the values from your own copy of the standard. No code tables are shipped; not certified or endorsed by any standards body.

Structures

Loads at every attachment, in line and structure axes. Allowable spans, load trees, 3D frame and truss analysis, wood, steel and concrete pole checks, usage reports worst first. A structure whose wires did not solve is reported incomplete.

Terrain and LiDAR

Survey points and TINs, LAS/LAZ and COPC, point clouds stored in the project with levels of detail, ground classification, as-built wire fitting.

More

Thermal rating after IEEE 738 and CIGRE, clearance-limited temperature, optimum structure spotting, bill of materials and cost estimate.

Drawings and exchange

  • SVG
  • DXF
  • PDF
  • PNG
  • XML (open schema)
  • LandXML
  • GeoJSON
  • Shapefile
  • GeoPackage
  • IFC
  • SAF
  • KML/KMZ
  • CSV
  • XLSX

Pre-alpha. Engineering results must be verified by a qualified engineer.

In active development

Extend it.
Don't fork it.

Add a design code, an import format, a terrain reader or a whole project importer as a WebAssembly component, written in any language against a WIT interface. Python covers scripts and reports, and a console runs inside the app.

  • Sandboxed: no file system, network or environment unless the manifest asks.
  • Exit clauses on every call: a time limit (5 s by default) and a memory cap (256 MiB).
  • A plugin manager in both applications: found, installed, turned on or off, with the reason one cannot be used.
  • Interface 0.3 (ohl:plugin, manifest ohl-plugin.toml): a design-code plugin can also provide clearance presets. Plugins built for an older interface must be rebuilt.
  • Limits a string may carry (rated load, swing angles) are handed to plugins with the solved forces and swings; OHL-Design itself does not check them.
  • A data model map for plugin builders: every object, file and reference a plugin sees.

Plugins distributed as separate files may use any licence.

ohl-plugin.toml
[plugin]
name = "my-format"
version = "0.1.0"
sdk = "0.3"
tier = "wasm"
entry = "my_format.wasm"
extension-points = ["io"]

[permissions]     # denied by default
network = false
filesystem = []

Collaboration

In active development

One line.
The whole team.

Host a project and others join it, like players on a game server. Every edit is checked by the server, applied in one order and sent to everyone.

  • Server mode (alpha): QUIC with TLS 1.3, invitations pinned to the server's certificate, roles and personal invitations.
  • Per-user undo, presence in the plan, soft locks while someone moves a structure, admin rollback.
  • Web client (base): 3D, plan and profile in a browser over WebGPU, with wires solved on the server.
Illustration: a main line with revisions, a design alternative branching off and merging back after reviewmainroute Bmerge after reviewtag
  • Version history inside the project file: revisions, branches for design alternatives, tags.
  • Diff with engineering impact: the sections touched solved on both sides, sag, tension and ground clearance compared.
  • Merge and review: object by object and field by field, protected branches, edit grants by kind, object or area.

Yours to read,
run and improve.

OpenOHL is licensed under the Mozilla Public License 2.0. Each domain is its own crate, so it can be improved, replaced or tested on its own.

Clean-room

An independent implementation built from standards, papers, textbooks and engineering knowledge. No decompiled code, no borrowed file layouts, documentation or UI assets.

Validation first

ohl validate runs the validation cases, each with a reference value and a tolerance, and fails when one drifts or runs out of time. A full validation report is a goal for 1.0.

Headless engine

Calculations run from the ohl command line and from Python scripts as well as in the applications.

Where it stands.

Pre-alpha. Everything on this page is built as a base and in active development; nothing is finished or approved yet. The roadmap lists what each part simplifies or leaves for later.

In development now

  • OHL-Structure, a separate structure application: levels 1 to 3, poles and extensions, body generators, symmetry and member groups.
  • Loads per placed structure: load-case recipes evaluated with the line's forces at each structure; cases with unsolved wires marked incomplete.
  • Structure analysis: joint stabilisation, tension-only members, member capacities and orientation, a dead-load factor.
  • Section library and exports: IFC4, IFC2x3, SAF and CSV, not yet tried in other programs.
  • In OHL-Design: the Replace structure tool, a structure picker with a preview, clearance presets from design-code plugins, ohl zones.
  • Plugins: interface 0.2, string limits handed to plugins.
  • Drawing speed: a frame benchmark for the views. On one project of a few hundred spans with a corridor survey, a plan-view frame went from 55–77 ms to 1.1–1.8 ms (one Apple M-series machine).

Coming

  • Code checks of structures

    Members and joints checked by design-code plugins; the interface is agreed first.

  • Structure-line interaction

    The structures' stiffness in the wire solve, then structures and line iterated until both converge.

  • Clearances to the structure body

    For pylons at detail levels 2 and 3.

  • More server and versions

    Editing in the web client, cherry-pick, visual diffs in the views, history export for audits.

  • 1.0

    A stable plugin SDK, a plugin registry, the complete theory manual and validation report, translations.

Further ahead

Two more applications on the same engine, in this order. Neither is started yet.

  1. 1. OHL-Foundations

    The foundations of the structures: foundation types and their checks, with the loads that the structure checks give.

  2. 2. OHL-Substations

    Substations: the gantries, busbars and equipment where lines end.

Get OpenOHL.

Free and open source. Pick your platform and how you want it.

1 Platform
2 How
3 Extras

Your setup

macOS · Build from source

  1. Install Rust (stable) from rustup.rs.

  2. Get the source and start OHL-Design with the synthetic example line:

    git clone https://github.com/Gay-Lussac/OpenOHL.git
cd OpenOHL
cargo run --release -p ohl-app -- \
  examples/synthetic-line/synthetic-line.ohl.json \
  --terrain examples/synthetic-line/synthetic-survey.csv \
  --weather examples/synthetic-line/weather-cases.ohlwc

View the source

Free under MPL-2.0. Pre-alpha: verify every result with a qualified engineer.

Read the docs