3 minute read

A systems-first approach to layout automation

The Problem We Ran Into (Repeatedly)

Layout automation doesn’t usually fail because of electronics.

It fails because complexity accumulates faster than understanding.

As layouts grow, several things tend to happen at the same time:

  • Wiring diagrams expand faster than anyone can reason about them
  • Configuration rules multiply, overlap, and become fragile
  • Troubleshooting turns into trial-and-error instead of diagnosis
  • “Just add one more thing” becomes a redesign event

This isn’t a skill issue. It’s an architectural issue.

Traditional approaches treat layout automation as a wiring problem with some logic layered on top. That works—until scale, change, or maintenance enters the picture.

LCC Fusion started when it became clear that wires were being asked to carry responsibilities they were never meant to handle.

The Core Insight

The key shift was this:

Stop organizing the system around connections.
Start organizing it around roles.

Instead of asking:

  • “How do I wire this turnout?”
  • “How do I connect this signal?”
  • “Where does this sensor land?”

We started asking:

  • Where does intelligence live?
  • Where does coordination happen?
  • Where do devices attach?
  • How does information move without creating dependency chains?

Once framed this way, the solution space changes dramatically.

What LCC Fusion Actually Is

LCC Fusion is not a single board, product, or kit.

It is a hardware architecture designed to make layout automation:

  • Scalable
  • Understandable
  • Incrementally buildable
  • Debuggable after installation

It does this by enforcing clear separation of responsibilities across four physical layers:

  1. Node (Intelligence)
    Where decisions are made and events are produced or consumed.

  2. Coordination (Bus & Hub)
    Where power and communication are distributed in a controlled, predictable way.

  3. Specialized I/O Cards
    Purpose-built interfaces that do one job well (signals, detection, motion, audio).

  4. Breakout Boards & Devices
    Where real-world wiring differences are absorbed and normalized.

This structure exists so that growth does not force redesign.

You can add devices without rewriting logic.
You can change logic without touching wiring.
You can debug one layer without destabilizing the others.

Why Events Matter More Than Rules

Another key decision was to embrace event-driven behavior end-to-end.

Instead of building systems around:

  • State tables
  • Polling loops
  • Tight device coupling

LCC Fusion treats the layout as a conversation of events:

  • Something happened
  • Someone cares
  • Action follows

This dramatically reduces cognitive load:

  • You reason about cause and effect
  • Not about signal paths or execution order

Importantly, this remains fully compliant with NMRA LCC standards while avoiding the “configuration cliff” that often comes with rule-heavy systems.

Why This Became Hardware (Not Just Theory)

These ideas could not live purely in software.

They required hardware that:

  • Reflected the architecture physically
  • Encouraged correct usage by design
  • Made incorrect wiring or scaling harder, not easier

That’s why LCC Fusion uses:

  • Modular cards instead of monolithic boards
  • Hubs instead of wiring stars
  • Purpose-specific interfaces instead of generic pinouts

The hardware exists because of the architecture, not the other way around.

What Exists Today

LCC Fusion is not a concept project.

It includes:

  • Working Node hardware
  • Specialized cards for sensing, control, signaling, audio, and power
  • Breakout boards designed for real layout wiring conditions
  • Extensive assembly, testing, and planning documentation
  • Podcasts and written posts discussing tradeoffs, mistakes, and evolution

Most importantly, it is being designed as a learning system, not just a control system.

How to Explore Further (Suggested Paths)

Depending on what you’re interested in, these are good next steps:

  • If wiring complexity is your pain point
    → Read Why Layout Wiring Gets Out of Hand

  • If you want to understand the architecture
    → Read The Four-Tier Architecture of LCC Fusion

  • If you’re curious how this scales
    → Read about the Fusion Node Bus Hub and expansion strategies

  • If you prefer discussion over reading
    → Explore the LCC Fusion podcast posts for conversational deep dives

All of these expand on the ideas introduced here without requiring prior context.

Why This Is Shared Publicly

LCC Fusion exists because many of these problems are systemic, not personal.

If this architecture helps:

  • You avoid rewiring a finished scene
  • You understand your layout better a year later
  • You teach someone else without overwhelming them

Then it has done its job.

This post exists to explain the why.
Everything else shows the how.

You may also enjoy