Flux Blog

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!

Let's break it down with a case study: a wearable AI pendant built around the ESP32-S3. It packs a microphone array, a LiPo battery with USB-C power, and a PCB antenna into a compact, power-efficient design. How would a design intended for a few prototypes differ from one built for mass production? More importantly, how can a designer transition from one to the other?

System Architecture: Modular Prototyping vs. Integrated Design

A design for prototyping is likely to start with an ESP32 development board, stacking breakout modules for power, audio, and sensors, and wiring everything together on a protoboard. This modular approach speeds up development, allowing rapid iteration and debugging. However, the result is often bulkier and less optimized for power efficiency and performance.

• Uses off-the-shelf breakout boards for rapid prototyping.
• Trades compactness and efficiency for ease of modification and debugging.

A production-ready design follows a different path. It begins with a block diagram, mapping out power distribution, signal paths, and communication protocols. Instead of separate breakout boards, all functions are integrated into a single custom PCB. This minimizes component count, optimizes trace routing, and ensures better signal integrity, ultimately leading to a leaner, more reliable system.

• Custom PCB design consolidates components for better power efficiency.
• Optimized signal paths reduce EMI and improve overall system stability.

How to Transition: To move from a prototype to a production-ready design, start by identifying frequently used breakout board components and replace them with equivalent ICs that can be integrated directly onto the PCB. Use search tools like Digikey’s filter or Copilot to narrow the search and check the reference design or application note in each datasheet you are evaluating. Use the prototype to refine the design before committing to a custom layout.

Power Management: Simplicity vs. Efficiency

A prototype design might use an AMS1117 linear regulator because it’s easy to wire up and doesn’t require extra components. A generic charging module is typically added, setting up a functional but inefficient system that dissipates excess energy as heat.

• Simple and quick to implement but inefficient in power usage.
• Lacks control over charging parameters, potentially reducing battery lifespan.

A production-ready design optimizes every power stage. The MCP73832T charging IC is chosen with a charge current precisely set based on the battery’s capacity. A MOSFET-based power switch ensures seamless transitions between USB and battery power, while a carefully selected low-dropout regulator (LDO) or buck converter maximizes efficiency, extending battery life and reducing thermal issues.

• Implements precise power regulation to optimize efficiency and heat dissipation.
• Ensures safe charging and switching between power sources for longevity.

How to Transition: Instead of relying on modular solutions, select integrated power management ICs suited for your voltage and current requirements. Optimize power paths by minimizing unnecessary regulators and designing efficient layouts to reduce power loss.

RF Design: Plug-and-Play vs. Precision Engineering

A prototype design may rely on the ESP32’s built-in PCB antenna, which works for initial development but can suffer from signal degradation due to poor placement and interference.

• Uses pre-certified ESP32 modules for convenience but may suffer from interference.
• May not account for optimal PCB placement, leading to reduced wireless range.

A production-ready design requires careful RF planning. The ground plane is optimized, and impedance-controlled traces ensure signal integrity. A matching network is tuned to improve impedance matching, reducing signal reflection and maximizing transmission efficiency.

• Ensures impedance matching and optimal antenna placement for improved RF performance.
• Carefully routes traces to reduce signal loss and unwanted interference.

How to Transition: Follow manufacturer guidelines for PCB antenna placement and matching networks. There are many resources and simulation software's to ensure accurate design like Ansys. Use impedance-controlled stack-ups in your PCB layout to ensure signal stability and range.

Audio Subsystem: Direct Connection vs. Signal Conditioning

A prototype might connect MEMS microphones directly to the ESP32-S3’s ADC, which works but is susceptible to noise. Single-ended connections can pick up unwanted interference, degrading signal quality.

• Directly connects microphones to the ADC for simplicity.
• May introduce noise and signal distortion due to lack of differential routing.

A production-ready design accounts for signal integrity. Differential microphone routing reduces noise, and DC-blocking capacitors are selected to fine-tune frequency response. Impedance-matched traces ensure reliable signal transmission, while an external ADC is used for higher fidelity audio.

• Uses differential routing to improve noise rejection and signal clarity.
• Carefully selects ADC components for optimal performance and power consumption.

How to Transition: If audio quality is a key requirement, incorporate differential microphone routing and external ADCs early in the design. Use simulation tools to validate signal integrity before committing to the layout. Always check the frequency response characteristics of the ADC and Microphone.

PCB Layout: Knowing When to Use AI Auto-Layout

PCB design benefits from automation, but knowing when and how to use AI Auto-Layout is key. A prototype design might rely on auto-routing for the entire board, allowing for quick prototyping and iteration. This speeds up development but may introduce unnecessary vias, tangled traces, and potential EMI issues.

• Uses AI auto-routing for full board layouts, enabling fast iteration.
• Optimizes for speed and convenience over signal integrity in early prototypes.

A production-ready design takes a hybrid approach. High-speed, sensitive signals, and power traces are manually routed to ensure signal integrity. Once these critical traces are placed, AI Auto-Layout handles the remaining connections, reducing design time while maintaining quality.

• Manually routes high-speed signals and power traces to optimize EMI performance.
• Uses AI Auto-Layout strategically to accelerate workflow without sacrificing design quality.

How to Transition: Start by routing critical signals manually, especially high-speed traces and power connections. Use AI Auto-Layout for non-critical traces, ensuring design efficiency without compromising quality.

The Takeaway: Shared Principles, Different Constraints

Prototyping and production-ready designs share the same fundamental principles: understanding tradeoffs, optimizing efficiency, and refining designs. A prototype prioritizes flexibility and quick iteration, while a production design optimizes for manufacturability, longevity, and performance.

Neither approach is inherently better; they serve different purposes. The best designers learn from both worlds. Those developing prototypes can incorporate creative design methodologies, while those working toward production can embrace the structured and precision of integrated design.

At the end of the day, electrical engineering isn’t about rigidly following a set of rules—it’s about making smart, defensible decisions based on the constraints at hand. Whether you're building a quick prototype or refining a production-ready device, the key is knowing the why behind every choice.

Want to see a full breakdown of this project? Check out the complete design walkthrough!

Why Library Size and Variety Matters

As any hardware designer knows, access to the right parts can make or break your design process. When the parts you need aren’t available, you’re forced to create them from scratch or search through endless online resources, slowing down your workflow and increasing the risk of mistakes.

With this launch, Flux is eliminating these obstacles. Our parts library has grown from 180,000 to over 800,000 parts this year alone, making it the largest, most comprehensive library embedded in any ECAD tool. With more parts available, you can now design faster, with greater confidence, and the reassurance that every component you need is readily available and up-to-date.

Smarter Searching and Filtering for Faster Part Selection

Finding the right part shouldn’t feel like searching for a needle in a haystack. With our expanded library, you now have access to enhanced filters and a smart ranking system that prioritizes parts based on their relevance and popularity within the community.

Here are some of the powerful filters now available in Flux:

• Part Type – Find components based on specific categories.
• Manufacturer – Filter by your preferred brands.
• Mount Style – Choose parts that suit your mounting requirements.
• Package Case Code – Select parts with the correct package type.
• Availability – Check real-time stock status from your chosen distributor.
• Compliance – Identify parts that meet regulatory or industry standards.
• Terminal Count – Filter parts by the number of terminals or pins.

These filters give you the freedom to design with precision, narrowing your search to parts that fit your exact specifications and are available in real-time. No need to jump between different sources to check stock—Flux brings live data right to you.

Real-Time Data That Keeps You Ahead

The new parts library also include live data that gives you valuable insights as you build. Here’s what you’ll find:

• Real-Time Availability and Pricing: Know exactly which parts are in stock and at what cost, so you can make informed decisions without jumping between tools.
• Lifecycle Alerts: Receive end-of-life warnings and other lifecycle alerts right within the design canvas.helping you avoid outdated components and future compatibility issues.
• Detailed Specs and Compliance Data: Access part specifications, compliance information, and detailed package options.

These improvements aren’t just conveniences—they’re essential tools that save you time and reduce the risk of expensive errors in your design process.

AI-Powered Workflows for Deep Research and Optimization

To help you find the best part for your project, we’ve added new, advanced filters that make selection faster and more precise. Here’s a quick summary, but check out our tutorial for a deeper dive:

• Compare Parts Side-by-Side
  Need to weigh your options? Drag parts onto the canvas and let Copilot guide you through a side-by-side comparison, highlighting key differences and helping you make an informed choice.
• Ask Datasheet-Specific Questions
  Save time on research by asking Copilot direct questions about datasheet information. Whether you need specs, capabilities, or compatibility details, Copilot pulls the answers you need, streamlining your design process.
• Find Replacement Parts
  When a part is out of stock or doesn’t meet your needs, Copilot can suggest alternative components that match your requirements, keeping your project on track without manual searching.

{{insert-1m-video}}

These AI workflows allow you to optimize your BOM for factors like cost, power efficiency, and compliance—all within the same tool. It’s like having an expert assistant by your side, making every design choice easier.

Ready to Start Building?

With 800,000+ parts and advanced tools at your fingertips, Flux is redefining what it means to design with confidence and speed. This expanded library is just one more way we’re empowering designers like you to do your best work, faster and more efficiently.

Open Flux today and start building with instant access to one of the industry’s largest parts libraries.

{{insert-go-to-flux-btn}}

That's why we're partnering with Seeed Studio. Together, we’re making it incredibly easy to bring your ideas to life.

With Flux, you can start with a ready-made project or a tailored template, customize it using Flux Copilot, and then let AI Auto-Layout handle the rest. Once your design is complete, Seeed takes over, fabricating, assembling, and shipping your project—at no cost.

Start with a Solid Foundation

The Seeed organization in Flux has everything you need to get started:

Ready-to-Clone Projects

These are complete, functional designs you can use as a starting point:

• Black Myth Wukong LED Art PCB: A stunning design featuring pixel LEDs and a Seeed XIAO ESP32-C3.
• WLED on XIAO ESP32-S3: A smart lighting controller ready to integrate with Alexa or Google Assistant.

Popular Board Templates

If you’re building something unique, start with one of Seeed’s board templates. These templates include footprints, pinouts, and configurations, so you can get to designing faster without starting from scratch.

Customize with Flux CoPilot

Once you’ve cloned a project or chosen a template, Flux Copilot helps you make it uniquely yours. Adding components, swapping LEDs, or refining connections. You can drop in new parts, and Copilot will automatically guide you through their placement and configuration, ensuring your changes fit seamlessly into the existing design.

1. Add Components: Drop in new parts and Copilot will help connect and configure them.
2. Modify the Design: Swap LEDs, add connectors, or tweak pin assignments without the guesswork.
3. Validate Changes: Copilot provides real-time guidance, ensuring your design stays functional as you customize.

It’s like having an expert engineer on your team, guiding you through each step. Learn more about Copilot.

Let Auto-Layout Do the Heavy Lifting

Once your schematic is complete, it’s time to move on to the layout. Traditionally, this step can be tedious and time-consuming, but Flux’s AI Auto-Layout changes the game. Instead of routing traces manually, Auto-Layout optimizes your board in minutes.

1. Generate Clean Routing: Auto-Layout finds the optimal paths for your traces based on your design constraints.
2. Ready for Manufacturing: The result is a clean, manufacturable PCB—done in minutes.

The AI intelligently routes components, generating clean, manufacturable designs with no extra configuration needed. During the optimization process, you’ll see multiple iterations of your design as the AI progressively improves the layout. Once it’s complete, you can review and select your preferred version, with the assurance that every option is optimized for manufacturing.

{{learn-auto-layout}}

Bring It to Life with Seeed

Here’s the best part: through the LED Remix Campaign, Seeed will manufacture and assemble your project—for free.

Create an LED-based design using a Seeed XIAO board in Flux, then submit to Seeed. Their Fusion service ensures your board is produced with high-quality standards and ready to use. Flux and Seeed work seamlessly together, with templates and ready-made projects optimized for manufacturing from the start. Export your Gerber files in just one click, and let Seeed handle the rest.

What you get:

• 2 PCBA Boards: Fabrication, parts, assembly, and shipping included.
• Free Flux Access: 2 months of full access to Flux.

Start Faster, Iterate Smarter

Ready to design? Here’s how:

1. Clone a Seeed Project or Template in Flux.
2. Customize Your Design with Copilot.
3. Auto-Layout to optimize your PCB in minutes.
4. Submit to Seeed and get your boards fabricated for free.

With Flux and Seeed, it’s never been easier to design, iterate, and manufacture PCBs. Start faster, and bring your ideas to life.