Bringing Modern Data Management into Custom IC Design: Integrating Keysight SOS Core with Synopsys Custom Compiler

In today’s semiconductor landscape, analog and mixed-signal design teams are under constant pressure to move faster without sacrificing quality. Tools like Synopsys Custom Compiler already provide a powerful environment for schematic capture, layout, and verification. But design productivity doesn’t just depend on tools. It depends on how well teams manage their data.

That’s where Keysight SOS Core comes in.

This post explores how SOS Core integrates directly into Custom Compiler, transforming it from a design tool into a fully data-managed platform- and why that matters for modern engineering teams.

Why Data Management Is the Missing Layer

Custom IC design is inherently collaborative. Multiple engineers work across schematics, layouts, and simulations, often distributed across locations and time zones. Without a robust data management system:

Custom IC design has quietly outgrown the workflows many teams still rely on. While tools like Synopsys Custom Compiler have evolved into highly sophisticated environments for schematic and layout design, the way teams manage design data itself often hasn’t kept pace.

That gap between powerful design tools and fragile data handling is where most inefficiencies, delays, and risks originate.

The Limits of Traditional Approaches

Many teams still rely on a patchwork of shared file systems, ad hoc naming conventions (think final_v3_real_final), manual communication through email or chat, and generic version control tools that weren’t designed for EDA workflows. While these methods may work in small, tightly coordinated teams, they begin to show strain as project complexity and team size increase. What starts as a simple system quickly turns into something brittle and difficult to manage.

For example:

These issues aren’t caused by shortcomings in design tools; they’re the direct result of inadequate data management.

Data Management as Infrastructure, Not Overhead

The key shift is to stop thinking of data management as an “extra tool” and start seeing it as core infrastructure- just like simulation or layout.

When it’s done right:

This is exactly why deep, native integration matters. When SOS Core is embedded directly inside Custom Compiler, data management stops being a separate task—and becomes an invisible enabler.

SOS Core: Built for Engineering Teams

SOS Core is designed specifically for small to mid-sized semiconductor teams that need reliability without complexity. At its foundation, it delivers:

Instead of copying massive datasets, engineers work with symbolic links to a shared cache. A 100 GB project can shrink to just megabytes locally, dramatically improving efficiency.

Native Integration with Custom Compiler

The real differentiator is how SOS Core integrates into Custom Compiler.

Rather than forcing engineers to switch tools, SOS embeds directly into the Library Manager and editor windows. All core operations- check-in, check-out, tagging, diffing, and updates- are accessible from familiar menus.

That means no context switching, no external tools and a minimal learning curve so designers continue working exactly as before, just with robust data management underneath.

Everyday Workflows, Reinvented

With Keysight SOS Core embedded directly inside Synopsys Custom Compiler, routine design tasks become more structured, consistent, and reliable. The result is a set of everyday workflows that feel familiar to engineers-but operate with a new level of control, visibility, and automation:

Version History and Recovery

Every design object (like a cellview) carries a complete history:

Engineers can quickly revert to earlier versions or filter revisions using labels like  “Gold”  or  “design_done.”

Hierarchical Operations at Scale

Analog designs are deeply hierarchical. A top-level block can include dozens (or hundreds) of dependent cells.

SOS allows engineers to operate on the entire hierarchy in one step:

This eliminates tedious, error-prone manual steps.

Automated Design Handoffs with Labels and RSO

One of the most powerful concepts in SOS Core is the combination of:

Together, they automate cross-team workflows.

For example:

No emails. No file transfers. No ambiguity.

Deep Visibility with Diff Reports

Understanding what changed between milestones is critical—especially for release engineering.

SOS Core provides  library- and hierarchy-level diff reports  that:

This gives teams precise insight into design evolution.

Branching, Merging, and Audit Trails

Parallel development is fully supported:

The audit trail answers critical questions like:

Built for Distributed Teams

Modern semiconductor teams rarely sit in one location.

SOS Core uses a Primary + Cache repository architecture:

A designer in one time zone can hand off work seamlessly to another—without coordination overhead.

Real-World Workflow: A Multi-Engineer Design Scenario

To understand how the integration of Keysight SOS Core with Synopsys Custom Compiler works in practice, it helps to look at a realistic multi-engineer design flow—from initial schematic development through layout and final release.

Project Setup

A project lead initializes the SOS project from the SOS GUI. The project repository stores all design data centrally, with Cache Repositories deployed at each engineering site. The project lead creates project views to give analog engineers visibility into analog libraries and layout engineers visibility into physical implementation data.

Schematic Design

An analog design engineer launches Custom Compiler and synchronizes their local workarea with the latest project data. The system immediately highlights any outdated design elements, allowing them to bring everything up to date before starting work. They then check out the top-level schematic for the analog front-end and begin making changes. After completing their edits, they validate the design through simulation to ensure everything behaves as expected. When satisfied, they check the design back into the system, adding a description of the changes and optionally linking the update to an issue tracker for traceability. At this point, SOS records a new revision and makes it available to the rest of the team.

Layout Design (Engineer)

A layout engineer at a remote site, opens the Audit Trail (Design Manager > Audit Trail) to review recent project activity. They configure the environment to prioritize the newly tagged schematic revisions and updates her workarea. This ensures they are working with exactly the versions the analog design engineer intended-no ambiguity, no manual coordination required.

They then proceed with physical implementation, completing the layout and running design rule and layout-versus-schematic checks. After verifying that everything meets requirements, they check their work into the system and apply their own milestone tag across the layout hierarchy, again using a single hierarchical operation to ensure consistency.

Release

The project lead steps back in to prepare the design for release. They create a project snapshot, capturing the exact state of every design object at that moment. This snapshot acts as a frozen, reproducible baseline that can be used for tapeout, future reference, or post-silicon debugging.

What stands out in this workflow is how little manual coordination is required. Each engineer works within their familiar design environment, while SOS ensures that data integrity, traceability, and handoffs happen automatically in the background.

Final Thoughts

The integration of SOS Core with Custom Compiler fundamentally changes how design teams operate. It brings version control, collaboration, and traceability directly into the heart of the design flow without disrupting how engineers work.

For teams building complex analog and mixed-signal systems, that’s not just a convenience. It’s a competitive advantage.

For more information visit  EDA Integrations | Keysight  or download the application note.

Related Posts

limit
3