This guide helps you choose the best hardware platform—Arduino, Raspberry Pi, ESP32, or others, by comparing power, connectivity, and scalability for your project.
Today, we’re excited to share our Summer Update to Flux AI Auto‑Layout, a collection of improvements designed to make one‑click PCB routing more reliable, transparent, and adaptable to your real‑world workflows.
This update is a set of pragmatic steps toward our vision of Auto‑Layout as your trusted routing assistant. Here's what's improved:
Auto‑Layout still works best when guided by thoughtful placement, clear net names, and rulesets—but now it’s a more predictable, collaborative partner in your design process.
Classify your nets into seven priority buckets—High Speed, Analog, Power, Medium Speed, Low Speed, Uncertain, and Ground—and Auto‑Layout will route them in that exact order. Flux will infer the Net Type of each net in your design, but you can check and change the inference by selecting a net and altering the Net Type property.
High‑speed nets go first.
Analog nets get their own quiet lanes.
Power nets find robust copper paths.
This helps ensure your most sensitive signals aren’t forced into awkward detours, delivering a draft layout that mirrors your own routing instincts.
Previous versions of Flux Auto‑Layout often scrunched traces up against neighboring pads or nets to minimize length. We’ve softened that bias so traces now favor open board areas—even if they grow a few mils longer.
Think of it as trading a few extra mils for a huge win in clarity and yield.
Earlier, Auto‑Layout could inadvertently slice through copper pours—especially smaller ones. Now, any polygon covering less than 10% of the board area is automatically protected from wires and vias unless you explicitly disable that rule.
Auto‑Layout shines when you guide it. Here’s a quick workflow that scales from beginners to power users:
Either way, Auto‑Layout becomes a force multiplier—not a replacement for your expertise.
This Summer Update is a milestone on our roadmap. In the coming months, expect deeper AI understanding of complex topologies, tighter integration with constraint management, and collaborative features that let teams iterate on one layout in real time.
Your feedback is the compass that guides us. Try the Summer Update today—log in, hit “Auto‑Layout”, and tell us where it shined or stumbled via in‑app feedback or our Slack channel. Together, let’s make routing the easiest part of hardware design.
In this post, we’ll show you exactly how to unlock the power of Flux Copilot for yourself: from writing rock-solid triggers to scoping entries at the project, user, and system levels.
Today, EE teams using Flux are already leveraging Knowledge Base to encode their professional know-how—things like project constraints, personal style guides, and industry-vetted best practices—directly into Copilot. In this post, we’ll show you exactly how to unlock that power for yourself: from writing rock-solid triggers to scoping entries at the project, user, and system levels.
Don’t miss out on this opportunity. Take these tips and tricks, apply them today, and watch Copilot transform from a tool into a teammate who thinks—and designs—just like you.
With Knowledge Base, we capture insights at three levels:
Let’s dive into how it works, why it matters, and—most importantly—how you can craft entries that make Copilot truly think like you.
Flux Copilot’s Knowledge Base entries can be thought of at four levels—from narrow rules to high-level mindsets. When you prompt Copilot, it performs a semantic search, a search that uses sentence structure similarity to find matches , then weaves the most relevant guidance into its reasoning.
Every entry begins with a “use when” phrase. Copilot uses vector search, finding similar items in a dataset by comparing their numerical vector representations (embeddings) instead of relying on exact keyword matches, to match your prompt to the right piece of advice based on semantic similarity.
When you ask Copilot, for example, to generate a buck-converter schematic, it retrieves relevant entries—your project’s input-voltage constraint, your favorite inductor series, or a net-naming rule—and seamlessly injects that context into its response.
The “use when” is the most critical piece of any entry—it tells Copilot when to apply your guidance, based on semantic similarity, not just keywords. If this is off, your advice will never—or always—fire.
Pro Tip: After Copilot suggests a “use when,” refine it immediately. A small tweak—“for high-speed analog filters” instead of just “for filters”—can mean perfect recall instead of irrelevant noise.
Project-level entries store all the details that make your current board design one-of-a-kind. They include specific requirements (like voltage tolerances), physical or thermal constraints, chosen topology decisions, and any reference calculations you’ve performed. By capturing the reasoning behind each architectural choice, Copilot can apply context-aware guidance tailored solely to this project. This prevents generic suggestions from slipping through and keeps your design aligned with its unique specifications.
use when: selecting temperature sensitive components
content: this design is exposed to temperatures of -10 F to 110 F on a Northeastern US State yearly temperature cycle.
use when: board size constraints
content: Ensure components selected are optimized for a wearable device sized board.
use when: designing a power distribution network
content: Optimize for small size and effeciency for each power component.
User-level entries capture your personal design preferences, workflows, and preferred subcircuit patterns so that Copilot reflects how you work. They let you encode procedural steps—like your favorite LDO selection or filter-design process—directly into Copilot’s memory. With these entries, Copilot adopts your schematic conventions, part choices, and step-by-step habits, producing outputs that feel tailored and familiar. In effect, it transforms Copilot from a generic assistant into one that thinks and advises just as you would.
use when: LDO selection process
content: When selecting an LDO, follow a structured four-step workflow: screen basic parameters, filter performance (PSRR, noise), prioritize the key metric, and check optional features.
use when: filter design process
content: When formalizing filter design, begin with clear specs (ripple, f_c, f_s, attenuation) and then proceed with topology selection, component choice, simulation, and disciplined prototyping.
use when: naming nets for differential pairs
content: Prefix with SIG_DP_ or SIG_DM_ and suffix with _N/_P for polarity clarity.
use when: naming nets with series resistors
content: Add a suffix _R to the name of the incoming net to the resistor and use it for the outgoing net name.
use when: designing op-amp instrumentation amplifiers
content: Add 10 Ω series resistors on each input to decouple source capacitance.
use when: using TI SN65HVD230 CAN transceiver
content: Place 120 Ω termination resistors close to the transceiver and add 0.1 µF decoupling on VCC.
Our EE team crafts system entries with the highest rigor—so every user benefits from vetted best practices.
Note: Every word is chosen deliberately—“use when” must be as true as the “content” it triggers.
As your KB grows, keep it relevant and helpful by:
Adding your knowledge to Copilot doesn’t just make it smarter—it makes you faster, more consistent, and more confident. Open Flux Copilot, watch for that “Knowledge Suggestion” button in the response, and begin teaching your AI teammate how you design. Over time, your Knowledge Base becomes a living encyclopedia of your best practices—project by project, decision by decision.
This update brings more than just polish—it’s the foundation for a faster, more fluid design experience, built around the way Copilot is used today and the way we see it evolving tomorrow.
Copilot is evolving fast—from a helpful assistant to a true design partner. Today, it can generate smart BOMs, place components in your schematic, suggest replacements, and even learn how you design through custom knowledge base entries. For many workflows, it’s already the fastest way to move your project forward.
But for Copilot to truly shine, the interface needs to get out of the way.
Until now, working with Copilot often meant bouncing between tabs—opening the object browser, toggling the Inspector, trying to remember where you saw something last. That’s friction. And friction slows down flow.
So we redesigned the layout to match how modern engineers work: with AI alongside them.
This update brings more than just polish—it’s the foundation for a faster, more fluid design experience, built around the way Copilot is used today and the way we see it evolving tomorrow.
This setup reduces interface friction—less tab switching, less mouse travel, and more continuous momentum throughout your workflow. The new layout improves the core ECAD experience too—placing the object browser and Inspector side-by-side, making it easier to inspect and modify your design at a glance. Less jumping around. More flow.
This isn’t just a visual update—it’s a real improvement in how you work. With the new layout, these tasks now feel dramatically smoother:
This update is more than just a layout shift. It reflects a core belief: AI isn’t just a feature—it’s becoming the interface. Looking ahead, we’re building toward a future where hardware design starts with a conversation. You’ll always have full control—nothing is hidden in a black box—but we envision a workflow where your ideas move from prompt to PCB through an intelligent, adaptable partner. Eventually, you may find yourself managing a team of AI collaborators, each handling part of the design process in parallel, all coordinated through natural language.
Flux is getting smarter, faster, and more intuitive—so you can spend less time managing tabs and more time designing boards. Whether you’re a first-timer or returning after a break, now’s the perfect moment to jump in.
👉 Open Flux and try the new Copilot-first layout today.
This month, we’re rolling out major upgrades to Flux Copilot’s reasoning, transparency, and layout performance—plus some crucial fixes and a big leap in modular design reliability.
A few weeks ago, we launched Copilot Knowledge—a way for you to teach Copilot how you work. As you approve suggestions, they become part of your personal or project memory: vendor preferences, naming conventions, design rules, review checklists, and more.
The result? Faster decisions, fewer mistakes, and better suggestions without repeating yourself.
Now we’re introducing the next layer: System Knowledge. This is a shared, curated knowledge base built by our team of senior engineers—including folks from NASA and other top hardware teams. They’re constantly encoding real-world insights, best practices, and edge cases that help Copilot make smarter choices across the board.
By combining your personal knowledge with system-wide expertise, Copilot becomes more responsive, more accurate, and more relevant to how modern hardware actually gets built. It now blends tribal wisdom with engineering logic to solve problems that used to require manual intervention—or years of experience.
Want to shape what Copilot knows? Hit us up in Slack or Canny with ideas—naming conventions, routing strategies, design rules. The more we share, the better it gets for everyone.
No more black box. Copilot now gives real-time feedback as it processes part selections and schematic requests.
You’ll see a live execution trace—how it searches, filters, ranks, and substitutes. It’s like watching a checklist unfold in real time. Whether you’re validating a part or building a schematic from scratch, Copilot shows exactly what it’s doing, and why.
Alongside transparency, we’ve made core performance improvements to Copilot’s part-selection engine:
These changes reduce wait time, improve reliability, and keep your momentum flowing during schematic design.
Thanks to your feedback, AI Auto-Layout just got a serious upgrade:
These changes make Auto-Layout results cleaner, more production-ready, and easier to tweak.
We’re not done yet. Here’s what’s coming next:
We resolved a core issue where polygons broke inside modules—restoring full support for airwire and copper DRC checks in modular designs. Now your modules behave predictably from design to fab.
All of this is live now—log in to Flux and give the latest updates a spin. As always, keep the feedback coming. We’re building Flux Copilot with you.
This post explains key signal integrity issues like crosstalk and reflections in PCBs and offers simple layout tips to avoid them. A free guide is included.
You followed the datasheet, double-checked the footprints, and kept your traces clean. But the moment your board hits production, there’s noise on the lines, your timing margins collapse, or worse: the board doesn’t pass compliance.
This is what Signal and Power Integrity (SI/PI) is all about, and why it’s critical even for everyday designs.
Signal integrity issues fall into three buckets:
If you’re using fast clocks, long runs, or high-speed I/O—even on a two-layer board—these issues can bite.
Crosstalk happens when traces run too close in parallel. The energy from one net bleeds into the other, distorting waveforms and injecting unpredictable noise.
You’ll see false triggers or glitches in digital nets, unexpected ripple in analog sections and most of the times -- EMI issues in test.
Want a shortcut? If your trace spacing is less than 3× the width, and they run in parallel for more than a few centimeters, you probably have crosstalk.
You don’t need a PhD or 8-layer board to fix this. Try these:
Board materials, stack-up, impedance, and even your decoupling caps play a role.
If your stack-up lacks solid return planes, or your dielectric isn’t up to spec, no amount of “good routing” will save you.
This is why we put together a complete guide that breaks down:
With checklists, diagrams, and cheat sheets to design boards that work the first time, for FREE.
{{download-high-speed-guide}}
Flux Copilot’s new AI-powered part search makes finding and placing components faster and easier using natural language. It eliminates tool-switching and datasheet overload. This streamlines your PCB design workflow.
As fellow hardware designers, we know how disruptive this process can be. That’s why we’ve redesigned part search in Flux Copilot using advanced AI techniques, so you can stay focused on your design, not the scavenger hunt. Whether you're early in your journey or deep into system architecture, this upgrade makes intelligent part discovery accessible and reliable.
If you're new to PCB design, just figuring out what components to use can feel overwhelming. You might not know the terminology, part families, or what trade-offs actually matter. The goal of Copilot is to give you answers, not more decisions.
You don’t need to know the right keywords or select from dozens of confusing filters. Just describe the part you need, like you would to a teammate.
Prompt: "Find an off board molex connector with 2x6 pin configuration at 2.4mm pitch with current ratings of 500mA per pin in the @library."
Copilot interprets the request, runs an intelligent search, and returns a clean table with real components, complete with specs, pricing, availability, and embedded datasheets.
Block diagrams are often your first step in scoping a design. But turning those blocks into real parts usually requires a second, manual pass.
Copilot eliminates that step. If you’ve created a block diagram in Flux, you can just ask:
Prompt: "Generate a BOM from this block diagram. Use parts available in the @library"
Copilot reads the intent behind each block and recommends components that fit, and are available in the library.
When you're new, it's hard to even know what to ask for. That's why Copilot uses the context of your design, voltage rails, interfaces, or constraints you've already defined, to guide its recommendations.
This is also where Copilot’s Knowledge Base really shines. If you’ve saved your preferred components, naming conventions, or layout guidelines, Copilot can use that information automatically, so its suggestions are already aligned with how you like to design.
Prompt: "Find a STM32 IC that has over 32 GPIOs, peripherals for 2x full SDIO, 2xI2S busses, and 3 QSPI busses from the @library"
Instead of a long list of generic op-amps, you’ll get options that fit the electrical and mechanical requirements of your board, with spec highlights that make it easier to choose.
If you're an experienced designer, you already know what you're looking for. But the search process still gets in your way, especially when you’re comparing subtle trade-offs, juggling PDFs, or jumping between tools.
Copilot now lets you move from part search to placement in one continuous thread.
Looking for second sources or similar components? Copilot understands part families and common alternatives.
Prompt: "I want to add an STM32I0 from the @library to this project. Can you recommend one from that family I can use?"
You’ll get a curated set of variants from different vendors, with key spec differences called out and datasheet previews inline. You can quickly assess whether a part meets your requirements, without opening five PDFs.
Context switching kills momentum. You find a part in one tool, then you’re off hunting for its symbol, then toggling over to assign a footprint, then digging through menus just to place it in your schematic. That back-and-forth might not seem like much, but multiply it by dozens of parts, and it adds up fast.
Copilot keeps you in the flow. Once you’ve found the right part, you can take action on it right in the same conversation. Search, validate, and place, all within the same conversation.
Prompt: "I wanto add a TCPP01-M12 from the @library to help protect my circuit electrically from the USB-C connector. Can you help me find it?
You can go from idea to implementation without friction:
Prompt: "Find an MCU for a low-power IoT node."
Prompt: "Place STM32L4R9 in my schematic."
Copilot pulls context-aware results, then places your selection with the right footprint and symbol directly into your schematic. This also works for passives, modules, and more complex components.
Prompt: "Add a resistor divider for a 12V to 3.3V conversion using 1% resistors."
With one thread, you go from requirement → component → placement, all without breaking your flow .
We’ve all been there, clicking through six different datasheets just to confirm one pinout or cross-check a quiescent current value. It’s slow, tedious, and pulls you out of your design flow.
If you're down to two op-amps with nearly identical specs, Copilot can analyze their datasheets and save you 5–10 minutes per part, and help you catch subtle but important differences before committing.
Prompt: "Show me 10 V LDOs under 100 µA quiescent current for battery-powered sensors."
You'll get a table with all the essentials, and you can inspect the PDFs directly, just like you would with tabs and downloads, but without the friction.
What makes this all possible? Behind the scenes, Flux Copilot now uses a combination of two powerful AI strategies: Hybrid Retrieval-Augmented Generation (Hybrid RAG) and an agentic search planning system built specifically for part discovery.
Let’s unpack that.
Hybrid RAG is the foundation, it runs two search engines in parallel:
Copilot fuses both results and re-ranks them based on relevance, so you're more likely to get answers that are both accurate and contextually useful. You don’t need to write the perfect query. Just describe what you need, and Copilot translates it into both a keyword and a semantic search behind the scenes.
But that’s just the starting point.
Copilot doesn’t just run one query and hope for the best. It creates a search plan, executes it, evaluates the results, and adapts, iterating until it finds components that truly match your design intent.
It knows, for example:
This matters because part search isn’t just about finding “a component that works.” It’s about finding parts that fit your schematic, your layout, your budget, and your workflow. And Copilot does that autonomously, in the background, while keeping you in control.
Think of it like designing for both performance and manufacturability. Copilot doesn’t stop at meeting the spec, it helps optimize for the full stack of constraints you care about as a hardware designer.
The result is a part search engine that behaves less like a query box, and more like a teammate who’s thinking alongside you.
The new part search is live now:
As hardware designers ourselves, we built this to remove friction and help you move faster, whether you're validating a quick prototype or heading into production.
Try it out, and if you have thoughts, questions, or edge cases you want to test, we’d love to hear about them in the Flux Slack Community.
