Flux Blog

We’re excited to announce one of the most requested features from advanced users: Curved Traces are now available in Flux!

Whether you’re routing high-speed buses, fine-tuning antennas, or laying out clean RF filters, sharp 90º or even 45º angles can be a serious bottleneck. Now, you can create precisely curved elbows across entire nets—or dial them in trace by trace—with full control over radius, inheritance, and overrides. Curved Traces were built to work the way you already do in Flux. You don’t need to micromanage every elbow—just set your rules once, and let the system handle the rest.

Need to override an elbow? You can. Want to apply curved traces to an entire layout? Go for it. You’re in the driver’s seat, and the system has your back with smart defaults, inheritance, and DRCs that surface only when needed.

This release sets the stage for what’s next: full support for flex and rigid-flex boards. Curved Traces are the first major unlock—and we’re actively building the rest. Flex is on the way.

The power of curved traces

This isn't just about cosmetics. Curved traces improve routing quality, unlock new design styles, and remove a major blocker for:

• Antennas and RF filters where MHz–GHz signals demand smooth, impedance-consistent transitions
• High-speed signals like DDR4 or HDMI that depend on tight length matching.
• Signal integrity-sensitive designs, where tight corners can accumulate charge and distort waveforms

Until now, you had to work around Flux’s sharp elbows. Now, you can design the way the pros do—with full control over every bend.

How to use curved traces in Flux

Curved Traces give you a new level of control over how your signals move across the board—whether you’re designing critical paths or polishing the final layout. To use curved traces:

1. Enable curved routing - Set the Trace Shape rule to "Curve" at the layout, net, or individual segment level. This tells Flux to apply curves instead of sharp elbows wherever possible.

‍2. Set a minimum radius - Use the Trace Corner Radius Minimum rule to define the smallest allowable curve. This helps ensure manufacturability—especially for tight layouts or impedance-sensitive routes.

‍3. Leverage inheritance - Apply your rules at the layout or zone level so they cascade automatically. You can mark rules as !important to make them stick when conflicts arise.‍

4. Override specific elbows - Need more control? Just click and drag the trace elbow or use Trace Corner Radius Start/End or Trace Shape Start/End to adjust a specific corner without affecting the whole trace.‍

5. Watch for DRC warnings - Flux will flag any elbows that can’t meet your minimum radius—so you can adjust your layout before it becomes a real problem.‍

6. Mix manual + auto-routing - Route critical traces by hand to maintain control—then auto-route the rest. Flux will respect your curved segments and finish the job cleanly.

If you’ve ever spent time nudging elbows, adjusting angles, or finessing a meander by hand, this is the update you’ve been waiting for.

Real projects. Real curves.

Want to see what’s possible? We’ve put together a few fully forkable example projects that showcase curved trace routing in the wild:

• RFID Antenna Board - High-performance RFID antenna solution built on a PCB configurations

• RF Filter Example – Controlled radii for consistent performance

Open them, explore the layout rules, and make them your own.

This is just the beginning

Curved Traces are a foundational feature—especially for advanced workflows. But they’re also a signal: we’re investing deeply in professional-grade capabilities, from stackups and automatic impedance control to AI auto-layout and AI-assisted design reviews. If Flux wasn’t quite enough for your pro projects before, now’s the time to jump back in.

Curved Traces are available to all users starting today. Just open any project, apply the "Curve" trace shape in your layout rules, and start routing. It's that simple.

Got feedback or something cool to share? Post in the Flux community or tag us—we’d love to feature your work.

Let’s bend some traces.

👉 Open Flux and try it now.

Copilot won’t generate an entire schematic from scratch or handle a full workflow in one go—yet. Instead, it works best when guiding you step by step. The more details you add—like project goals, placed components, or design constraints—the more context Copilot has to carry across conversations, making its recommendations more relevant and accurate.

We've updated our list of top prompts based on what users find most effective, helping you streamline everything from brainstorming and component research to BOM management and design validation. Here’s how to get the best results from Copilot—and a collection of powerful prompts to speed up your workflow.

Popular Copilot Prompts

Spread the word and share your favorite prompts on our Slack Community. Below, we’ve grouped some favorite prompts by category. Each section starts with extra tips to help you get the most out of that set of commands.

{{top-copilot-prompts-v2}}

Ever since we launched Copilot, our goal has been to create a truly collaborative design partner—one that goes beyond offering advice to actually executing on your behalf. Today, we’re thrilled to unveil the next major leap in that journey!

Copilot is now powered by more advanced reasoning models and has the full context of your project—datasheets and your custom design rules—enabling far faster, and more accurate recommendations than any standalone AI chatbot could offer. Best of all, you remain in control, free to accept or refine any of its actions as you progress.

This isn’t just an upgrade—it’s a whole new way to design hardware with AI. Let’s dive in!

Get Started Easier & Generate a BOM

Starting a new hardware project can feel overwhelming. Even if you know exactly what you want to build, transforming your idea into a functional schematic requires choosing components, verifying specs, and ensuring each piece fits together seamlessly.

The completely overhauled Copilot takes the guesswork out of this process by engaging you in a focused conversation about your project. Instead of juggling datasheets and sourcing websites, you simply outline your goals—like “I want to build a battery-powered sensor module with an ESP32”—and Copilot follows up with questions to refine your requirements as a seasoned hardware engineer would.

Copilot: "Sounds great! Which sensors would you like to use—temperature, humidity, or something else?"

Once your specs are clear, it compiles a Bill of Materials (BoM) in seconds, giving you a curated list of compatible, optimized parts. You can review and adjust any element of the BoM before moving forward, confident that you’re building on a rock-solid foundation—without wasting hours on manual research.

Add Components Directly to the Schematic

After finalizing your BoM, Copilot can take the next step by placing each component into your schematic—whether it’s a microcontroller, sensor, or power module. It searches the library and drops parts onto your canvas in a way that avoids overlap, so you’re not starting from scratch.

Decoupling Capacitors in Seconds

With your key components in place, the next step is fine-tuning the design—often starting with decoupling capacitors. Traditionally, you’d consult datasheets for recommended values and place each capacitor manually. Copilot streamlines all of that into a single prompt:

You: "List all the decoupling capacitors that are needed for this design."

Copilot: "Below is a recommended list of decoupling capacitors for your sensor module design. Would you like me to add them to your schematic?"

Copilot identifies which parts need decoupling, calculates the optimal values, and places the capacitors next to their relevant pins. This alone can save you hours of research and tedious work, letting you maintain focus on the bigger picture.

Automatically wire components

Once your parts are positioned, the next challenge is ensuring everything is correctly wired—pin assignments, best practices, net labeling, and so forth. With Copilot, wiring becomes as straightforward as telling it which components to connect:

You: "Can you connect @U1 to @U3?"

Normally, this would mean double-checking pinouts, referencing datasheets, and verifying each signal. Copilot handles those checks behind the scenes, making the required connections in seconds. You can still review and adjust as needed, but the bulk of the manual labor is eliminated.

Smart Component Replacement

Even if your schematic is fully functional, there’s often room for optimization—maybe you need a sensor with higher resolution or a regulator that handles more current. Instead of searching for alternatives on your own, let Copilot do the legwork:

You: "Find a better alternative for U1 in the @library that has a higher resolution."

Copilot scans for a suitable match, checks it against your existing circuit constraints, and offers a drop-in replacement. Once confirmed, it updates your schematic accordingly—no library lookups needed.

More Ways to Guide Copilot

While Copilot automatically picks the best tools and models for most tasks, sometimes you need a little extra control. Whether you’re pulling equations from a datasheet, sourcing components from the Flux library, or performing quick calculations, prepending an "@" symbol tells Copilot exactly which tool or model to use—so you can fine-tune your workflow.

Tool-Specific Commands

• @file ties Copilot directly to any files attached to your project—like datasheets or design briefs—ensuring it references the most relevant information.
• @library gives Copilot a direct line to the entire Flux component library, making it easy to find, compare, and insert compatible parts.
• @calculator lets Copilot perform real-time math using datasheet equations, so you can size components accurately without manual computations.

Model Selection Made Simple

You can also choose from multiple AI models, each suited to a specific task:

• Advanced Reasoning – More capable but slightly slower, ideal for deeper technical analysis.
• General – A balanced option, both accurate and responsive for everyday tasks.
• Speedy – Faster responses for quick checks, though less detailed.

This flexibility ensures you’re always getting the right balance of speed and detail.

✨ Pro Tips for Best Results

• ‍Break Tasks Into Steps. Copilot works best when given one task at a time. Instead of asking it to build an entire schematic, begin by telling Copilot what you want to build, then give it specific prompts like “@copilot, suggest a temperature sensor suitable for outdoor environments.” After selecting a component, proceed with, “@copilot, add the recommended temperature sensor to the schematic.” Finally, instruct, “@copilot, connect the sensor's output to the analog input of @U1.”​‍
• Provide Context. The more details you add to your project—like goals, requirements, attached datasheets, or components on the canvas—the better Copilot performs. These details act as Copilot’s “long-term memory” across conversations.‍
• Use Specific Tools. Utilize tags like “@library” to reference parts libraries or “@file” to attach datasheets. Specifying design parameters further refines Copilot's recommendations.​‍
• Watch for Action Buttons. When Copilot identifies executable tasks, an action button will appear in the chat interface. Clicking this allows Copilot to perform the task directly on your design. If the button doesn't appear, consider rephrasing your request or breaking it down into smaller steps.

AI as Your Design Partner

This release marks a pivotal step toward the future of AI-assisted engineering. Flux Copilot isn’t just here to answer questions—it’s evolving into a genuine design partner, one that helps you move faster, reduces friction, and keeps you focused on real engineering challenges. But we’re only scratching the surface of what’s possible.

Our larger vision is to automate even more of the tedious steps in hardware design—like routing and board layout. If you haven’t already, check out our AI Auto-Layout feature, which aims to take care of basic board routing so you can iterate faster and get to market sooner.

Join the Beta & Share Your Feedback

Right now, Copilot is in a community beta. While it’s more capable than ever, it’s not perfect—and that’s where you come in. Your feedback will shape its evolution. Tell us what works, what doesn’t, and what actions you’d like Copilot to tackle next.

We’re rolling out new features in the coming weeks. If you don’t see them yet, keep an eye on Flux—or join our Slack and message Nico to get in early.

Ready to experience AI that truly takes action?

{{open-flux-try-copilot}}

Today, we’re excited to share the preview of AI Auto-Layout, powered by Flux Copilot. This is the next step toward full layout automation. With just one click, Copilot tackles the repetitive task of routing your board, delivering clean, human-like results that are easy to work with and iterate on. Whether you're working on a simple or moderately complex design, AI Auto-Layout helps you stay in the flow while saving hours of effort.

Easy setup

One of the biggest challenges with traditional autorouters is the complexity of setup. By the time you’ve configured everything, you might have already routed the board manually. AI Auto-Layout eliminates this frustration by providing a streamlined, fully integrated experience with smart defaults that’s easy to use for beginners while remaining powerful and customizable for advanced users.

For simple and medium-complexity boards, the smart defaults handle most configurations for you, so all you need to do is finalize your schematic, place your components, and hit “Auto-Layout.” The smart defaults for trace width and spacing are intelligently applied, allowing you to focus on design, not setup.

If you need more control, advanced customization is only a few clicks away. Add keep-outs, define custom trace widths, and set advanced constraints to meet specific design requirements. Learn more about how to setup your project by watching this video tutorial or reading the documentation on AI Auto-Layout.

Iterating with AI Auto-Layout is also seamless. Feel free to route part of your board with critical, or high speed traces, and then allow AI Auto-Layout to complete the busy work. Whether you’re relying on defaults or customizing advanced constraints, AI Auto-Layout starts routing with just a single click.

This combination of simplicity and flexibility makes AI Auto-Layout accessible to anyone, from beginners building their first PCB to professionals designing for production. It’s routing that adapts to your needs, not the other way around.

Human-like results

Traditional autorouters often treat routing as a purely mathematical exercise, optimizing only for shortest paths without considering practical realities like manufacturability, signal integrity, and clarity. The result is all too familiar: tangled, robotic layouts that are tough to debug and frustrating to iterate on.

Flux’s Auto-Layout takes a completely different approach. By using advanced AI techniques—especially Reinforcement Learning (RL)—it finds routes that feel intuitive and professional. Instead of following rigid, one-size-fits-all rules, RL allows the AI to continuously adjust its decisions. It learns from each choice, honing in on cleaner, more balanced arrangements that reflect real-world design priorities.

As Auto-Layout runs, you can watch the layout improve over multiple iterations and accept or cancel at any point. Simple boards might converge on a good solution in a matter of minutes, while more complex projects may require longer—sometimes 10-15 minutes or even several hours. The result is a PCB layout that’s easier to understand, refine, and trust.

Examples of AI Auto-Layout’s Human-like Results:

Sensitive Power Trace Prioritization: Auto-Layout identifies critical power traces and prioritizes them for optimal routing, preserving signal integrity and minimizing interference.

Crystal Oscillator Signal Routing: Auto-Layout ensures crystal oscillator signals take the shortest path to the clock input, reducing degradation and interference, while maintaining safe distances from other nets.‍

Throughout this process, your data remains yours. We employ robust encryption and modern data centers to keep your information secure, just like the trusted cloud services you rely on daily. If you want to learn more, please take a look at our Privacy Statement.

Try AI Auto-Layout

We’re thrilled to introduce AI Auto-Layout as part of a preview release, with access rolling out gradually. If you’re a new user, you’ll have free Copilot credits included in your 2-week trial, which you can use to explore the feature if you’re granted access. For paid users, AI Auto-Layout uses the Copilot credits already included in your plan. Need more credits? Visit Plans & Payments to keep your projects on track.

Your feedback is essential to helping us refine and improve AI Auto-Layout. Join us on this journey to make PCB design smarter, faster, and more intuitive for everyone.

Inside the Example Build

This example takes inspiration from the popular “Figma Creator Micro,” which was designed to speed up design software workflows. We wanted a similarly compact macropad with plenty of customization.

Key Components and Features:

1. Raspberry Pi Pico 2 (RP2350A)

• The latest Pico variant, provides more power and capability.
• Offers native USB HID functionality, so your custom macropad can be recognized as a keyboard.

2. External Flash Memory (W25Q32RVXHJQ)

• 3V, 32M-bit serial flash with dual/quad SPI & QPI.
• Useful if you need extra storage for more complex macros, animations, or data logging.

3. Two Rotary Encoders (PEC12R-2220F-S0024)

• Adds dial-based input for volume, scrolling, or continuous adjustments.
• Each encoder can also include a push-button switch, depending on the model.

4. Slide Potentiometer (PTA2043-2010CIB103)

• Provides smooth, precise adjustment—great for volume, brightness, or scrubbing through a timeline.

5. Mechanical Key Modules

• Each “module” includes a Kailh PG1353 low-profile clicky switch, an RGB LED (WS2812-2020), and a diode.
• Using modules in Flux means one click = the entire key circuit. This modular approach simplifies duplication and future updates.

Layout & Automatic Ground Fill

We used Flux’s automatic ground fill to ensure easy, noise-free connections across the board. Smart vias also help optimize routing, especially in compact designs. That keeps your layout clean and production-friendly.

See the Schematic and PCB: Open/Clone the Example Project in Flux to explore the design step by step. If you want a no-fuss option, you can literally just fork and order it as-is.

Step 1: Fork the Example

1. Open the Project: Click this link to open the project
2. “Fork” in Flux: This copies everything—schematic, PCB layout, modules—into your workspace.
3. If you love the project and want to manufacture it as is, feel free to skip to Step 5.

Step 2: Understand the Modules & Connections

Before you start tinkering, it helps to see how everything fits together. If you’re not sure why certain parts are included or how they’re wired, you can simply ask Flux Copilot, our AI assistant, right in the project.

Example Copilot Prompts:

@copilot can you explain how the Mechanical Key Module is wired to the Raspberry Pi Pico?

@copilot what’s the function of the external flash memory in this design?

@copilot can you outline how the two rotary encoders are connected?

@copilot which GPIO pins are currently free for additional keys or sensors?

You can also request a high-level overview of the entire project:

Copilot will respond with details about components, pin assignments, and even why certain parts were chosen, helping you understand the design before you dive into any major customizations.

Step 3: Customize the design

A quick way of personalizing this design would be to add some more keys. Each Mechanical Key Module is pre-built with the switch, diode, and LED. If you want more (or fewer) keys:

1. Copy the Module in the schematic.

2. Ask Copilot for an unused GPIO on the RP2350. Type:

@copilot Find a free GPIO Pin on the RP2350 where I can connect a new key

3. Let Flux Copilot handle the actual schematic wiring if you’d like. Type:

@copilot connect Key13 GPIO X

For the rotary encoders and slide potentiometer, you’ll see them already placed in the schematic. Feel free to move them around, switch to different pins, or remove them if you don’t need them.

Step 4: Arrange components and run AI Auto-Layout

Switch to the PCB editor to see the current footprint placements.

1. Move Stuff Around: Want the Pico on the left edge for easier USB access? Just drag it.
2. Add or Remove Key Modules: If you duplicated or removed keys in the schematic, you’ll see that reflected here.
3. Run AI Auto-Layout: Click “Auto-Layout.” Flux’s AI engine will handle trace routing, ensuring a clean layout.

Repeat or tweak until the board shape, connector positions, and overall look match your preferences.

Step 5: Finalize & Order

1. DRC Checks: Flux flags any design-rule violations in real-time. Address issues if they pop up (like overlapping components or unconnected nets).
2. Ground Fill & Stitching: We rely on Flux’s automatic ground fill for noise reduction. No need to do it manually.
3. Export Gerbers or Order Directly: Once satisfied, generate manufacturing files or send them straight to your chosen PCB board house.

That’s it! You’ll have your custom macropad PCB in hand in a couple of weeks—ready to solder and test.

Step 6: Program the Pico

We’ve included a MicroPython firmware example that handles debouncing, RGB lighting, rotary encoder tracking, and custom macros. You can tweak it however you like: add more key commands, change LED effects, or even integrate USB HID keyboard functionality.

Below is the full example code:

import machine
import utime
from neopixel import NeoPixel

# Define GPIO pins for switches
SWITCH_PINS = [2, 3, 4, 5]  # Assign GPIOs for your 4 macro keys
switches = [machine.Pin(pin, machine.Pin.IN, machine.Pin.PULL_UP) for pin in SWITCH_PINS]

# Define debounce time to avoid false readings from bouncing switches
DEBOUNCE_TIME = 20  # 20 ms debounce

# Define GPIO pins for encoders
ENCODER_A = machine.Pin(6, machine.Pin.IN, machine.Pin.PULL_UP)
ENCODER_B = machine.Pin(7, machine.Pin.IN, machine.Pin.PULL_UP)

# LED control (assuming WS2812 or other RGB LEDs)
LED_PIN = machine.Pin(15, machine.Pin.OUT)
NUM_LEDS = 4
leds = NeoPixel(LED_PIN, NUM_LEDS)

# Variables to track encoder state
encoder_position = 0
last_encoder_state = (ENCODER_A.value(), ENCODER_B.value())

# RGB Color values
OFF = (0, 0, 0)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
WHITE = (255, 255, 255)

# Macro definitions
MACROS = {
    0: 'Volume Up',
    1: 'Volume Down',
    2: 'Next Track',
    3: 'Previous Track',
}

# Timer to avoid debounce issues
def debounce(pin):
    last_state = pin.value()
    utime.sleep_ms(DEBOUNCE_TIME)
    current_state = pin.value()
    return last_state == 1 and current_state == 0

# Key press handler with debounce and macro execution
def check_keys():
    for i, switch in enumerate(switches):
        if debounce(switch):
            print(f"Key {i+1} pressed")
            execute_macro(i)
            led_feedback(i)

# Execute macro action based on key pressed
def execute_macro(key):
    macro = MACROS.get(key, "Undefined Macro")
    print(f"Executing {macro}")
    # Advanced users can add HID USB keyboard functionality here
    # For example, using the 'uhid' module or CircuitPython's USB HID library

# LED feedback function with color cycling for each key press
def led_feedback(key):
    colors = [RED, GREEN, BLUE, WHITE]  # Different colors for each key
    leds.fill(OFF)  # Clear all LEDs
    leds[key] = colors[key % len(colors)]  # Cycle through colors for each key
    leds.write()

# Encoder read function to track position and detect rotation
def check_encoder():
    global encoder_position, last_encoder_state
    current_state = (ENCODER_A.value(), ENCODER_B.value())
    
    if current_state != last_encoder_state:
        if current_state == (0, 1):  # Clockwise
            encoder_position += 1
            print(f"Encoder rotated clockwise: {encoder_position}")
        elif current_state == (1, 0):  # Counterclockwise
            encoder_position -= 1
            print(f"Encoder rotated counterclockwise: {encoder_position}")
        
        # Apply color change based on encoder position
        adjust_led_brightness(encoder_position)
        last_encoder_state = current_state

# Function to adjust LED brightness based on encoder input
def adjust_led_brightness(position):
    brightness = max(0, min(255, position * 10))  # Scale brightness from 0 to 255
    print(f"Adjusting LED brightness to: {brightness}")
    leds.fill((brightness, brightness, brightness))  # Uniform brightness for all LEDs
    leds.write()

# Main loop with key check, encoder check, and periodic updates
while True:
    check_keys()
    check_encoder()
    utime.sleep(0.05)  # Short delay to prevent CPU overuse

How to Flash:

• Put your Pico in bootloader mode. (Hold the BOOTSEL button while plugging it in via USB.)
• Drag-and-drop a .uf2 build of this code onto the Pico drive.
• Or use a MicroPython IDE (like Thonny) to upload the .py script directly.

We Want to See Your Mods!

A macropad is a fun, hands-on introduction to designing professional-grade PCBs with Flux—while still being small and easy to iterate on. Using modules, AI Auto-Layout, and built-in Copilot means you can move fast, experiment freely, and end up with a fully functional device you’ll actually use every day.

Ready to fork this design and customize the hardware, firmware, or both?

• Add More Keys: Throw in extra mechanical key modules.
• Go Wild with RGB: Make each key’s LED do something different.
• Try a Different Microcontroller: If you need more GPIO or different features.
• Join Our Slack: We’d love to see build photos and code snippets.

Share your unique designs in our Flux Slack Community for a chance to be featured in an upcoming showcase!

We can’t wait to see your take on this build—happy designing!

AI Auto-Layout is not just another autorouter—it’s an intelligent assistant that continuously learns and refines its results based on user feedback. If you've ever felt frustrated with traditional auto-routing tools, this guide will show you how to achieve clean, professional layouts with minimal effort. Let’s dive in!

1. Setup Your Board for Automatic Differential Pairs

Differential pairs are essential for high-speed designs, ensuring minimal signal distortion and optimal power transfer. Flux's AI Auto-Layout can route differential pairs automatically if your components and nets are correctly configured.

• Understanding Differential Pairs in Flux: Differential signals require matched impedance and trace lengths to function properly. Flux simplifies this by allowing users to define differential pairs at the schematic level, ensuring AI Auto-Layout routes them correctly. For more information check Flux’s documentation.

• Best Practices for Using AI Auto-Layout with Differential Pairs:‍
  • Configure Components Correctly: Ensure the differential pair properties are assigned to component pins or nets to enable AI-based routing by adding the ‘Signal type’ property. Also ensure the pin and net names match the protocol standard naming conventions like D+ and D- for the USB protocol. ‍
  • Maintain Manufacturable Spacing: AI Auto-Layout enforces a minimum spacing and trace width of 5 mils to align with common PCB manufacturing standards.‍
  • Validate Impedance and Length Matching: After routing, verify impedance-controlled traces and ensure net length consistency to meet high-speed design requirements.

2. Setup Your Components for Automatic Power Tracewidths

Power integrity is crucial for any PCB design, and AI Auto-Layout incorporates an automatic copper width calculator to optimize power traces efficiently.

• Understanding Power Routing in Flux: Power traces must support current requirements while minimizing resistance and heat buildup. AI Auto-Layout considers these factors when determining trace widths.
• Best Practices for Power Traces in AI Auto-Layout:
  • Set Current and Thermal Constraints: Assign 'Current' and 'Desired Temperature Rise' properties to power pins to ensure AI Auto-Layout selects appropriate trace widths.
  • Ensure Copper Pour Connectivity: Verify that power traces properly connect to ground and power planes to maintain voltage stability.
  • Review High-Current Paths: Identify critical high-current traces and manually validate their routing to prevent excessive resistance or overheating.

3. Create Rulesets for Repeatable Design

Rule sets in Flux allow you to efficiently apply layout rules across multiple objects using selector-based syntax, making design more consistent and AI Auto-Layout more effective.

• Understanding Rulesets in Flux: Unlike object-specific layout rules, selector-based rules can apply to multiple objects simultaneously. These rules use selectors, which are inspired by CSS Selector Syntax, enabling you to define broad but precise layout constraints. By applying rulesets across multiple objects, AI Auto-Layout can use them to optimize routing decisions. This ensures that design constraints are consistently enforced across your project.

• Best Practices for Creating Rulesets:‍
  • Standardize Naming Conventions: When creating nets in your schematic, ensure that net designators follow a structured format. For instance, power nets can use prefixes like “PP,” “VCC,” or “VDD,” followed by voltage levels such as “3V3” or “5V0.” This makes it easier to select and apply rulesets to all nets of a given voltage.‍
  • Reuse Rulesets Across Projects: Many designs have similar rulesets for power, signal, and high-speed traces. By reusing established rulesets, you can accelerate the design process and reduce errors.

4. Use Zones to Keep Your Layout Clean

Zones in Flux are a powerful way to define keep-out regions of any shape or size on any layer, allowing you to control where AI Auto-Layout routes traces.

• Understanding Zones in Flux: Zones are primarily used for specialized design areas, such as antenna sections or high-voltage isolation, but they can also play a crucial role in AI Auto-Layout by restricting routing paths.

• Best Practices for Using Zones with AI Auto-Layout
  • Prevent Routing Under Sensitive Components: Use zones to avoid routing under components like crystal oscillators, power inductors, and ADCs; where signal integrity is critical.‍
  • Permanent Keep-Outs Reflected in Gerber Exports: Since zones define copper voids, when exporting your PCB for manufacturing, ensure you remove the temporary zones. A quick way to do this is to standardize their designators and create a ruleset to enable them for routing and disable them for manufacturing.

5. Handling Long Run Times & Ensuring Convergence

AI Auto-Layout continuously optimizes routing decisions, but for complex boards, it may take longer to converge on an ideal solution. Following these best practices will ensure more efficient routing.

• Understanding Convergence in AI Auto-Layout: The AI engine iterates through multiple routing strategies, refining the design progressively. The process can be accelerated by pre-optimizing constraints.

• Best Practices for Managing Run Time and Convergence:‍
  • Review DRCs Before Running AI Auto-Layout: Fixing design rule violations beforehand ensures smoother execution and prevents unnecessary re-routes.
  • Identify Critical Nets for Manual Routing: High-speed and impedance-controlled traces may benefit from manual pre-routing before engaging AI Auto-Layout.
  • Monitor Airwires and Copper Connectivity: If routing appears incomplete, review airwires and ensure nodes are correctly connected to avoid unintended open circuits.
  • Evaluate Early Convergence Points: AI Auto-Layout often finds valid solutions before full convergence—review interim results and determine if additional iterations are necessary.

AI Auto-Layout is Evolving – And So Can You!

AI Auto-Layout is the fastest-evolving AI-driven PCB design feature in history. We’re actively listening to user feedback and prioritizing enhancements based on real-world use cases. If you haven't tried it yet, now’s the perfect time to experience the future of PCB design.

Get started today and see how AI Auto-Layout can transform your workflow. With continuous improvements rolling out, this tool will only get better—and your designs will too!