RungsA Continuis Labs ExperimentUpload your PLC export. Get the documentation you wish you'd had.
Rungs reads Rockwell L5X, Siemens TIA Portal, and CODESYS exports and produces the structured documentation that should have shipped with the program. Routine summaries in plain English. I/O cross-references. Flagged anti-patterns. Audit-grade markdown that lives in your repo — not changing your control logic, just preserving the knowledge in it.
Every plant inherits its own undocumented program. Every shift loses a little more institutional memory.
The person who wrote the routine retired in 2019. The naming convention shifted twice. The 'comments' are PLC comments — a sentence per rung if you're lucky, abbreviations you can't decode if you're not. The wall of paper schematics is two revisions out of date.
When something goes wrong at 2 AM, you're not reading documentation. You're reading the program. Hoping the previous engineer thought the same way you do.
The fix isn't to rewrite anything. The fix is to make the program legible — to your night shift, to the new hire next quarter, to the auditor next year. Rungs reads what you already have and writes the documentation the program should have shipped with.
- 0%
- of inherited PLC programs come with usable documentation
- 12h+
- average to manually document a medium-complexity routine
- 75%
- of plant downtime root-caused to undocumented code or wiring
controls-engineer community consensus
industry estimate
EIT / LearnTechnique research
Six layers. Read your exports. Write the docs. Never touch your logic.
Rungs is read-only by design. The L5X / TIA / CODESYS files you already export for backup are what Rungs ingests. Nothing about your running program changes; what changes is whether anyone can still read it next year.
- 01
Upload — every vendor's native export
Drop in a Rockwell L5X, a Siemens TIA Portal export, or a CODESYS .projectarchive. Rungs accepts what your engineering team already exports for backups; you don't change any workflow.
- Rockwell L5X
- Siemens TIA
- CODESYS
- 02
Parse — vendor-aware, never modifying
A dedicated lexer per vendor walks the file: routines, tags, comments, AOIs, structured text. Rungs is read-only by design — the source file is never altered, never written back, never deployed.
- Read-only
- Per-vendor parser
- AOI-aware
- 03
Cross-reference — the I/O usage graph
Every tag is traced through every routine. Where it's read, where it's written, which subroutine owns it, which task it runs in. The thing your wall-of-paper schematics used to provide.
- I/O graph
- Tag provenance
- Task scoping
- 04
Document — plain English, by an engineer who reads ladder
Each routine gets a summary written like a senior controls engineer onboarding the night shift. Rung-by-rung intent, not just a transcription. Anti-patterns flagged, not auto-corrected.
- Routine summaries
- Anti-pattern flags
- Plain English
- 05
Schematic — markdown-rendered logic flow
Sequence diagrams for state machines, dependency trees for safety interlocks, signal-flow maps for analog chains. Renders in any Git repo viewer, prints clean, doesn't need a license.
- Mermaid
- Markdown
- Print-ready PDF
- 06
Export — to your repo, audit trail intact
Push to Git, save to PDF, drop into a SharePoint. Every line of documentation traces back to a rung in the source. Auditors can verify; new hires can ramp; you don't lose the knowledge when someone leaves.
- Git
- Audit-grade
Source on the left. Docs in the middle. Audit-grade artifact on the right.
Toggle the source pane between the raw L5X export and the rendered ladder diagram (the format your engineers actually read). Toggle the deliverable between the markdown schematic and a styled PDF. The middle pane — the documentation itself — stays put.
Starts the packaging-line conveyor when the operator presses Start, with safety interlocks for E-stop and guard door. Run command latches until Stop is pressed; the latched run drives the motor VFD. Three rungs, no AOIs, no timers — straightforward start/stop with the standard safety chain a packaging line should have.
| Tag | Type | Read | Write |
|---|---|---|---|
| Start_PB | Discrete Input | Rung 0 | — |
| EStop_Healthy | Discrete Input | Rung 0 | — |
| Guard_Closed | Discrete Input | Rung 0 | — |
| Stop_PB | Discrete Input | Rung 1 | — |
| Conveyor_Run | Internal Bit | Rung 1 | Rung 0 |
| Conveyor_Run_Latch | Internal Bit | Rung 2 | Rung 1 |
| Out_Motor_Run | Discrete Output | — | Rung 2 |
Conveyor_Run is written in Rung 0 and re-read for latching in Rung 1. A single sealed-circuit rung (XIC in parallel with the latch bit) is the canonical Rockwell pattern — easier for the next engineer to read.
Field wiring should still use a normally-closed E-stop circuit. Confirm the Stop_PB hardware contact matches this expectation in the wiring schedule.
Rungs Documentation Report
Conveyor_Start · MainLine
Controller
PACKAGING_LINE_A
Routine — Conveyor_Start
Type: Ladder Logic (RLL) · Generated: 2026-05-26 16:55 UTC · Source hash: sha256:a4f1…2c9d
1. Summary
Starts the packaging-line conveyor when the operator presses Start, with safety interlocks for E-stop and guard door. Run command latches until Stop is pressed; the latched run drives the motor VFD output.
2. I/O Cross-Reference
| Tag | Type | Read | Write |
|---|---|---|---|
| Start_PB | Discrete In | Rung 0 | — |
| EStop_Healthy | Discrete In | Rung 0 | — |
| Guard_Closed | Discrete In | Rung 0 | — |
| Stop_PB | Discrete In | Rung 1 | — |
| Conveyor_Run | Internal | Rung 1 | Rung 0 |
| Conveyor_Run_Latch | Internal | Rung 2 | Rung 1 |
| Out_Motor_Run | Discrete Out | — | Rung 2 |
3. Rung Breakdown
Rung 0
Start conveyor on operator request when E-stop is clear and guard interlock is closed.
XIC(Start_PB) ∧ XIC(EStop_Healthy) ∧ XIC(Guard_Closed) → OTE(Conveyor_Run)
If the operator presses Start, the E-stop circuit reports healthy, and the guard door is closed, energize the Conveyor_Run flag. This rung is the safety chain entry point for the routine.
Rung 1
Latch run command until stop pressed (no edge detect).
XIC(Conveyor_Run) ∧ XIO(Stop_PB) → OTE(Conveyor_Run_Latch)
Once Conveyor_Run is set, this rung holds Conveyor_Run_Latch energized as long as Stop_PB is not pressed. Pressing Stop drops the latch immediately.
Rung 2
Drive output to VFD.
XIC(Conveyor_Run_Latch) → OTE(Out_Motor_Run)
The latched run state energizes Out_Motor_Run, which connects to the VFD start input. Field documentation: see drawing PKG-A-EL-014, sheet 3.
Source views are read-only. Toggle the deliverable to compare what lands in your repo vs. what prints to the binder.
The documentation package, in one ingest.
Drop in an export. Get the artifacts your operators, auditors, and new hires actually need — on every regeneration, in the format each one prefers.
- 01Parser
Vendor-native parsing of L5X, TIA, CODESYS
Dedicated lexers per vendor walk routines, tags, AOIs, structured text, and scoped variables structurally — not guessed at from raw text. AOIs and function blocks unfolded into their definitions.
- 02Outputs
Markdown, PDF, and audit-grade HTML
One run produces a repo-ready .md, a printable PDF for the binder, and an HTML view for the audit team. Every line of every artifact carries provenance back to a specific rung and a source-file hash.
- 03Memory
ChangeLog between revisions
Point Rungs at v1 and v2 of the same routine and it explains what semantically changed in plain English — the institutional record of why a control loop looks the way it does today.
- 04Q&A · coming
Ask questions of your own documented programs
Once your routines are documented, ask Rungs how an I/O flows, why a rung is structured the way it is, or where to look first when a specific alarm fires. Grounded in your code — not the public internet.
Your file. Your network. Your IP.
Rungs is designed for plants that treat a controller backup as proprietary by default. Three guarantees about where your data goes — written down, not buried in a privacy policy.
On-prem option ships at v1
The Enterprise tier runs the parser, the language model, and the documentation store entirely inside your network. No outbound traffic, no telemetry. For regulated facilities and OEM-confidential logic, this is the default deployment.
Cloud tiers are tenant-isolated
Free / Pro / Team uploads are encrypted in transit, processed inside an isolated per-tenant environment, and the parsed AST is what the language model sees — not the raw export. Nothing is retained beyond your subscription.
No training corpus. Period.
Your routines never feed any model — not the model Rungs uses, not any third-party model, not a future fine-tune. The business model is per-routine pricing, and the data-handling story is the same regardless of tier.
Pricing that scales with routines, not with how many engineers your plant employs.
Pricing locks in the day the product ships. Reserve the early-access tier now to lock in 50% off for life — see below.
Free
For trying it on one routine and seeing the output.
$0/mo- 3 routines / month
- Watermarked PDF export
- No team features
- Community support
- Most popular
Pro
For one engineer documenting one site.
$29/mo- Unlimited routines
- No watermark, all output formats
- Git, PDF, Markdown export
- Email support
Team
For a controls team sharing one documentation library.
$99/mo- 5 seats
- Shared library
- Audit log
- Cross-routine search
Enterprise
For regulated plants and OEM-confidential logic.
$499/mo- SSO + RBAC
- On-prem / air-gapped option
- Vendor support agreements
- Procurement-friendly contracts
Reserve a Pro plan at $14/mo — 50% off, for life.
First 200 reservations only. No charge until launch — refunded if Rungs doesn't ship within 6 months.
What ships after v1.
Driven by what controls engineers in the waitlist conversations have actually asked for.
- Q1 after launch
Siemens TIA + CODESYS parity
Rockwell L5X is the v1 target. Siemens TIA Portal exports and CODESYS .projectarchive follow immediately after.
- Q1 after launch
Git auto-commit + PR descriptions
Hook Rungs to a Git remote and every documentation regeneration lands as a PR with a clean diff and a human-readable changelog.
- Q2 after launch
Conversational Q&A on your documented programs
Ask Rungs how a specific I/O flows, why a rung is structured the way it is, or what to check first when an alarm fires — grounded in your routines, not the public internet. Troubleshooting guidance with citations back to specific rungs.
- Q3 after launch
AOI / FB library cross-plant search
Search every routine you've ingested for a specific add-on instruction or function block — across sites, across vendors, across years.
The earlier you join, the more you shape v1.
I'm Tom — a data engineer with 4 years of production IoT, including running real-time data infrastructure for plants with exactly this documentation problem. If you've inherited code you can't read, your input shapes Rungs.
Honest answers.
Will Rungs change my PLC program?
No. Rungs is read-only. The L5X / TIA / CODESYS export you feed it is the only thing it sees, and it never writes back to the controller, never deploys, never pushes a new program. The artifact Rungs produces is documentation, in your repo or your chosen export format. Your control logic on the floor is unchanged.
Will my code leave my network?
Depends on the tier. Free / Pro / Team are cloud-hosted: the upload is encrypted in transit, processed in our managed environment, and the parsed AST is what the language model sees (never the raw export). Enterprise runs everything inside your network — parser, model, storage. For regulated plants or OEM-confidential routines, Enterprise is the only correct answer.
What formats are supported at v1?
Rockwell L5X is the v1 target — that's where the largest underdocumented installed base lives. Siemens TIA Portal exports and CODESYS .projectarchive ship in the first quarter after launch. If you have a specific vendor we should prioritize, the waitlist form has a use-case field — tell me there.
How is this different from just asking ChatGPT to summarize a rung?
Three differences: (1) the parser knows the actual file format and extracts structure — routines, tags, AOIs, scoping — not text. (2) The output is a multi-file structured documentation artifact (markdown, PDF, schematic) that lives in your repo, not a chat thread. (3) Every line traces back to a specific rung in the source, with provenance — auditable, signable, defensible.
Does it document Studio 5000 Add-On Instructions (AOIs)?
Yes — AOIs are first-class. The parser walks into the AOI definition and documents both the AOI interface (parameters, scope) and the implementation. Same for Siemens function blocks and CODESYS POUs in v2.
Can I edit the generated docs?
Yes — the output is markdown. If a routine summary is missing context that only your team knows (a customer-specific quirk, an undocumented historical incident), you edit the markdown directly. Rungs preserves your edits on the next regeneration and only updates the auto-generated sections.
When will it launch?
Depends on validation signal from this page. If the waitlist hits critical mass in the next two weeks, I start building full-time and target v1 in 10–14 weeks (parsing alone is non-trivial; getting AOI handling right is the long pole). If not, I respect your time and don't keep you on a list for vaporware.
Will you train AI models on my plant's program?
No. Your routines stay in your tenant. The language model is invoked with your AST + a system prompt; the responses are not fed back into any training corpus. The business model is per-routine pricing, not data resale.