rungs.dev Manifesto

rungs.dev is a tool we're building to make PLC programming easier, especially for people who write AOIs (Add-On Instructions), teach automation, or just want to test and share logic without hardware or expensive licenses. It's early in development - most features are still missing - but the core idea is simple: isolate logic, test it fast, and document it automatically.

What's wrong with the usual way?

In most PLC environments you're forced to work inside a big, often messy project. Everything depends on everything else. It's hard to isolate and verify just one fragment of the logic.

Another big issue is accessibility. The tools are expensive, locked behind licenses, and usually tied to Windows. That's a barrier for students, educators, or anyone who just wants to write PLC code quickly. Even the free options often require long downloads and installations that might not end up useful.

And then there's the mental load. Because logic is buried deep inside full projects, it's hard to document, test, reuse, or share anything in a clean way.

The 9 Rungs Manifesto

Inspired by the nine rungs of Apollo 11's lunar lander ladder, these are the nine principles behind rungs.dev - the things I believe matter most in our mission to provide you with a useful tool.

1. Accessibility

Accessibility in rungs.dev means removing the typical barriers of PLC development. The goal is to let anyone, anywhere, work on logic without being held back by operating system requirements, licensing costs, or complex installation steps.

This principle is about enabling people to jump straight into creating and testing logic, whether they're a student at home, an engineer on a lightweight laptop, or a hobbyist curious about automation. By making the environment easy to access, rungs.dev encourages experimentation and learning without the friction that usually stops beginners and slows down professionals.

Ultimately, accessibility is about freedom - the freedom to focus on your logic, not on how to get the tool running.

2. Affordability

Most industrial software is priced for companies, not individuals. With rungs.dev, the goal is to provide a free tier that covers nearly everything - editing, testing, simulating, and sharing - so anyone can start learning and building without a financial barrier.

Paid plans are essential to support the app's development, but only power users will ever need them. The core experience stays open, giving people a way in rather than keeping them out.

Tools should help you grow, not gatekeep your learning.

3. Isolation

This is the whole point of rungs.dev. You don't need to buy a PLC rack or install an expensive simulator to test a single AOI. Just write your code, define your parameters, and run the logic in isolation.

Isolation makes it easier to test, understand, and document what your code is actually doing without being distracted by everything else in the system.

4. Testability

rungs.dev will let you define test cases: set your inputs, run the AOI, check the outputs. Repeat with edge cases. If something breaks, you'll know exactly when, where, and why.

Mocking signals, testing failure paths, and automating input sequences should be part of everyday PLC work, not an afterthought.

The idea is to make testing so fast and easy that you do it all the time, not just when something goes wrong.

5. Collaboration and sharing

Eventually, rungs.dev will have a public AOI library - a place to share useful logic blocks, browse examples, and import things into your own workspace.

You'll also be able to export AOIs, fork them, comment on them, and build your own internal libraries. Teams can standardize and reuse their best logic instead of rewriting the same thing ten times.

For now, this is just a plan. The foundation is in place, but the UI and sharing system still need to be built.

6. Documentation-first

Every AOI in rungs.dev is defined by its parameters. Once you set those up, documentation almost writes itself.

You'll get an auto-generated view of inputs, outputs, and descriptions - enough for others to understand how your logic works without digging into the code.

That's good for sharing, good for teaching, and good for your future self when you come back to the same AOI six months later.

7. Professional-grade

Just because it's simple doesn't mean it's a toy. rungs.dev is meant for people who care about writing good, reusable logic.

You can focus on clear, algorithmic thinking in ST or visual logic in Ladder - whichever suits the task. The goal is a tool that feels natural to professionals and inviting to learners alike.

This tool should feel comfortable to professionals who've worked on real machines, not just classroom projects.

8. Versionability

PLC tools have terrible version control. Most people just save copies with names like final_v5_REAL_FINAL. That's rough.

rungs.dev will eventually include proper version tracking for each AOI. You'll be able to fork, revert, and track changes, just like you would in software development.

This is especially important for teams, documentation writers, and anyone who wants to avoid overwriting working logic by accident.

9. Continuous learning

rungs.dev is designed to grow with you. It's a good place to start if you're learning Structured Text. But it should also stay useful once you're building real logic for real machines.

Teachers can use it to show one concept at a time. Developers can use it to experiment with new control ideas. Teams can build training examples, libraries, and demos.

Because everything is isolated, you can build from simple to complex without changing tools.

What's next?

If this sounds useful, keep an eye on it. It's early, but the vision is clear. We're building rungs.dev to make PLC logic easier to write, test, and share - one rung at a time.