RF engineer Dr. Juergen Kienhoefer switched from Eagle to Flux, gaining 2–4× productivity by eliminating manual part creation. AI checks, fast support, and a rich component ecosystem made the move permanent.
Flux brings circuit simulation to wherever you are in the design process. Start from a prompt when you have no schematic, or let Flux analyze your existing design automatically.
Flux now has built-in circuit simulation, and your AI design assistant knows how to use it.
If you've ever designed a circuit board, you know the feeling. You finish your schematic, send it off for fabrication, wait for the boards to arrive, and then hold your breath. Will it work? Did you get the filter cutoff right? Is that decoupling cap actually sized correctly?
For most of hardware design history, the answer has been: build it and find out.
Simulation was always supposed to solve this. And technically, it can. SPICE has been around for decades. But in practice, simulation has been so cumbersome to set up that most engineers skip it entirely. Even some of the best-resourced hardware teams in the world have left simulation on the table because the overhead just isn't worth it for everyday design decisions.
That changes today.
We're introducing circuit simulation built directly into Flux. Describe what you want to simulate in plain language through the Flux AI chat, and Flux handles the rest: building the netlist, configuring the analysis, running the simulation, and returning charts with clear explanations.
No setup wizard. No exporting netlists. No switching tools.
Two ways to start:
From a prompt. Don't even have a schematic yet? Just describe the circuit and what you want to measure.
You: "Simulate a first-order RC low-pass filter with a 10 kΩ resistor and 10 nF capacitor. Generate the bode plot and find the -3 dB cutoff frequency."
Try this prompt
Flux: Runs an AC sweep, returns the bode plot, reports the -3 dB point at ~1.59 kHz, and confirms it matches the theoretical value of 1/(2πRC).
One sentence in, full analysis out.
From your schematic. Already have a design in progress? Even better. Flux pulls context from your parts, net connections, and datasheets to build the simulation automatically. You don't need to export anything or set up a separate project. Just ask.
You: "Simulate the voltage across C3. Show me the output ripple voltage in a plot.
Check the actual project.
Flux: Uses the components and connections already in your design, runs the analysis, and returns results without you specifying a single component value.
Your schematic is the test bench.
The simulator handles the kinds of analyses engineers actually run day-to-day:
Passive or active, from simple RC low-pass to second-order Sallen-Key and multiple-feedback topologies. Get bode plots, -3 dB points, phase response, rolloff slopes, and bandwidth in seconds.
Try it: "Simulate a second-order Sallen-Key low-pass filter using an ideal op-amp, with equal resistor values of 10 kΩ and equal capacitor values of 4.7 nF. Produce the bode plot, identify the corner frequency, and report the slope after cutoff."
Try this prompt
RC charge/discharge curves, step responses, debounce circuits, pulse timing. Verify time constants and measure voltage thresholds over time.
Try it: "Simulate an RC charging circuit with a 5 V step input, a 100 kΩ resistor, and a 1 µF capacitor. Plot the capacitor voltage over time and report the time to reach 63.2% and 90% of final voltage."
Try this prompt
Measure ripple across rectifier circuits, filter stages, and switching approximations. Compare ripple across different capacitor values without rebuilding the test bench every time.
Try it: "Simulate a full-wave bridge rectifier using 0.7V-per-diode bridge model, with a 15 V RMS 50 Hz AC source, a 1000 µF filter capacitor, and a 100 Ω load. Report the average DC voltage, ripple frequency, and peak-to-peak ripple voltage."
Try this prompt
The simulator is powerful, and a little context on how it works helps you get more out of it.
It runs on industry-standard SPICE. Under the hood, Flux uses a proven SPICE engine with access to a verified component library of 340,000+ models. When you request a simulation, Flux interprets your request, constructs the netlist, configures sources and analysis parameters, executes the simulation, and returns results with clear explanations.
Component models matter. Flux draws from its verified model library automatically, but here's what happens at the edges:
It's conversational, not one-shot. Think of simulation in Flux as a back-and-forth. If the first result isn't quite right, adjust parameters, zoom in on a range, or ask for a different visualization. The iteration is the workflow, not a sign that something went wrong.
Start with what you know. If you have a rough idea of expected results (a ballpark cutoff frequency, a target ripple range) you'll be able to validate output quickly and course-correct.
Here's where things come together. Because simulation lives inside the same AI assistant you're already using to design, results don't just sit in a chart. They feed back into your workflow.
Ask Flux to simulate a circuit, evaluate results against your spec, and adjust component values if the numbers don't work out. Instead of hand-calculating a filter cap value and hoping for the best, you can size it based on actual simulated performance.
This works for nearly any quick validation: filter cutoffs, ripple targets, timing thresholds. Describe what "good" looks like, and let Flux iterate toward it.
The fastest way to verify a circuit is to just describe it.
{{open-flux-and-try}}
This Spring 2026 updates make hardware design faster end-to-end with a more capable, self-correcting AI agent, improved AI auto-layout that needs less cleanup, sourcing-aware design with real-time pricing and availability, and templates to start from.
This spring, we’ve made Flux faster, more capable, and more practical across the full hardware design workflow.
Today, we’re introducing the Spring 2026 Update: a major upgrade to how Flux helps you research parts, build schematics, lay out boards, and design with sourcing in mind.
With these updates, we bring together a faster, more self-correcting AI agent, major improvements to AI Auto-Layout, intern-like multi-step execution, and real-time supply chain visibility built directly into the design workflow. The result is a faster path from idea to board, with less manual busywork and fewer late-stage surprises.
Flux now helps with more of the hardware design workflow end to end, from planning and part research to schematic work, layout, and sourcing-aware decisions.
You can describe what you want to build in terms of goals, constraints, interfaces, power targets, and preferred components, and Flux can turn that into a step-by-step plan spanning parts research, schematic creation, layout, checks, and review milestones. As it works, it shares progress, explains decisions, and checks in at key moments so you can steer the design without micromanaging every step.
That shift matters because hardware work is rarely a single action. Real progress comes from coordinating many decisions across planning, implementation, verification, and iteration. The Spring Update is about making that full workflow feel dramatically more natural inside Flux.
At the core of this update is a major upgrade to how Flux executes design work.
The agent was rebuilt around a new architecture, execution model, and verification system designed to improve three things at once: speed, correctness, and reliability.
One of the biggest changes is that the agent now checks its own work continuously while it operates. Instead of generating a result and leaving validation until the end, it runs ERC and DRC checks as it goes, catching issues like floating pins, missing connections, and rule violations in real time. That means cleaner schematics on the first pass, fewer manual fixes, and fewer wasted iterations.
{{table}}
It’s also more adaptive during execution. Rather than following a fixed plan from start to finish, the agent evaluates progress after each step and adjusts as it works. If it encounters a conflict or finds a better path forward, it updates its approach and continues. In practice, that makes it more effective across both lightweight tasks and more complex multi-step jobs.
We’ve also continued to improve AI Auto-Layout based on real usage and feedback.
This update focused on making results cleaner, easier to review, and more manufacturable. Routing now converges faster, with shorter traces, fewer vias, and paths that better follow placement intent. Layouts are more legible, and the system more reliably produces results that need less cleanup before handoff.
For many teams, that is exactly the right division of labor: human judgment on what matters most, AI speed on the busywork in between.
Good hardware design depends not just on performance, but on choosing parts that are actually available.
Most EDA tools still treat sourcing as something you check after the design is already locked. But by then, a BOM change can ripple through the whole project. Flux’s approach is different: pricing and availability stay connected to the project while you work, so supply constraints surface early, when design decisions are still flexible.
With the Spring Updates, that means you can:
This is a meaningful change in workflow. Instead of designing first and negotiating with reality later, you can make sourcing-aware decisions as the design takes shape.
Every hardware engineer has rebuilt the same circuits dozens of times. Voltage regulators, programming headers, decoupling networks, reference designs for common microcontrollers.
Flux now makes it possible to start from reusable design foundations instead. Engineers can fork reference designs, microcontroller platforms, and manufacturer rule templates, then adapt them for their specific application. Teams can also build internal templates that encode their own design standards, compressing the gap between a new idea and a working architecture.
This is the last of the five updates, and the most foundational in terms of workflow change, not because the technology is the most complex, but because it reframes where design work actually begins.
Together, these improvements make Flux more useful at every stage of hardware design.
If you’ve used Flux before, now is a good time to run a workflow you already know well and feel the difference for yourself.
{{try-it-in-flux-today}}
Flux is like a reusable starting-point library for hardware design. Browse templates and public projects, fork one that matches your use case, then modify and expand it as your design evolves.
Here's how to take advantage of it.
Here's a quick reference for discovering content:
#reference-design, #template, or #manufacturer-design-rules to browse curated categories.This is one of the biggest time-savers we see. Many users search for a microcontroller, like an ESP32 or an ATmega328P, and drop the bare chip into a blank project. Then they spend either the next hour wiring up peripherals manually or ask AI to add the crystal, decoupling caps, voltage regulator, USB-to-serial bridge, and boot circuitry that every design needs.
A smarter move: start with a reference design that already has all of that done.
The most popular reference designs on Flux right now are:
{{reference-design-table}}
ESP32 is far and away the most searched term on Flux. If you're building with an ESP32, starting from the ESP32-WROOM-32E Reference Design or the ESP32-S3 Reference Design will save you significant setup time.
Use the search bar at the top of Flux and search for your microcontroller name, or try the tag #reference-design to browse all reference designs in the library.
You can also select a reference design directly from the template picker when you create a new project.
Once you've cloned a reference design, you can modify it for your needs with Flux, just tell it what you want to add or change, and it'll update the schematic for you.
If you already know which fabrication house you're going to use, start with a manufacturer template. These come pre-configured with the correct design rules (trace widths, via sizes, clearances) for that specific manufacturer, so you don't have to manually configure them, and you won't get hit with DRC violations right before you export.
The most popular manufacturer templates on Flux:
{{manufacturer-template-table}}
Search for #manufacturer-design-rules in Flux, or select a manufacturer template from the new project dialog.
Some of the most-used content on Flux is fully built example projects that teach you how to use specific features. These projects have been cloned and forked tens of thousands of times because they let you learn hands-on.
The most popular projects:
{{example-project-table}}
Open any of these, click Fork, and you'll have your own editable copy in seconds.
The reference designs and templates in this post exist because someone published their work. If you've built something reusable, a template with manufacturing spec rules, and a clean reference design, publish it. The next person searching for your exact use case will find it.
{{link-to-featured-projects}}
Today we’re excited to share that Flux has raised $37M in new funding led by 8VC, with participation from Bain Capital Ventures, Liquid 2 Ventures, and Outsiders Fund, alongside Lenny Rachitsky, John Lilly, and Tom Preston-Werner and many other world-class operators.
We raised this capital for one reason: to accelerate our mission to take the hard out of hardware and keep pushing until building hardware feels as easy and iterative as building software.
We started Flux with a simple belief: hardware design should move faster, feel more collaborative, and fit the way modern teams actually work. We were also excited about what AI could unlock for hardware as early as 2019, back when that was not the obvious bet. Looking back, we were very early, frankly too early, and only a few of the use cases we envisioned were really possible at the time, at least not reliably and not at the scale serious teams need.
Looking back, we’re glad we started early. It gave us time to lay the foundation and build Flux to be AI-first before it was the obvious move. When LLMs hit their stride, we were ready to plug them in quickly and learn by shipping. We listened closely, fixed sharp edges, hardened the platform, and iterated until Flux started to feel like the tool we always wanted to use.
If you stuck with us and kept sending feedback, thank you. That feedback is a big part of why the product is meaningfully better today. To date, 1,099,361 builders have used Flux to create 6,425,482 projects, and this raise gives us the resources to move faster and to help more builders move through the hardware workflow with less friction.
This funding lets us move faster on the parts of Flux that matter most for serious work. Here are the three areas we’re investing in with this additional funding, and what it means for you.
You can already direct Flux with prompts and have it execute multi-step workflows. With this funding we are making it faster, more capable, and more reliable, and we are also making it easier to use so you can get more done with fewer steps.
Trust is everything, so we are making the agent more predictable and clearer about when it is uncertain. You should know when to trust it, when to verify, and when to step in. You steer, Flux executes, and you stay in control.
We are investing in the core platform so you can design complex boards with confidence. That means better performance at scale, fewer frustrations, and output you can trust when it is time to build.
The AI uses the same editor you do, so every platform upgrade also upgrades what the agent can do.
Hardware is a team effort, and the tooling needs to fit into existing workflows. We are already connected with many popular distributors, and we are doubling down on building a robust parts library grounded in real availability and real workflows.
As integrations mature, we’ll keep expanding what Flux can connect to, including manufacturers, simulators, and the tools your team relies on. We’ll follow demand.
None of this exists without you.
If you’ve given us feedback, pointed out sharp edges, shared projects, or stuck with Flux while we earned the right to be part of your workflow, thank you. If you want something improved, whether that is agent behavior, eCAD capabilities, or ecosystem connections, tell us. We read it all and it directly shapes what we prioritize.
We are going to keep shipping.
Thank you for being here.
Lance, Matthias and the Flux team
Flux's AI agent is now up to 10x faster and self-corrects in real time, delivering cleaner schematics with less waiting and fewer wasted credits.
That usage showed us exactly where to focus: speed, correctness, and reliability. So we rebuilt the agent from the ground up with a new architecture, execution model, and verification system.
Login to try the updated agent today! Here's what changed.
The agent now does a better job checking its own work as it goes by, continuously running ERC and DRC checks against the design, catching floating pins, missing connections, and rule violations in real time. The result: cleaner schematics on the first run, fewer manual fixes, and fewer wasted credits.
The agent no longer follows a fixed plan from start to finish. It evaluates progress after each step and course-corrects along the way. If it hits a conflict or finds a better path, it updates its plan and keeps going.
Ask it to drop in a single component, and it stays lean and fast. Give it a full power management system, and it will work through the complexity iteratively until the design passes its checks. That means more complete, more correct results across a wider range of tasks.
All of this happens in parallel. The new agent places components, routes connections, and verifies results at the same time, collapsing what used to be a long sequential pipeline into a fraction of the time.
Complex jobs that previously took 30+ minutes now finish in under 5. You spend less time waiting and more time iterating on your design. Faster completion and fewer retries also mean your credits go further. And we've done all of this without raising prices.
We ran the same prompts on the old and new agents. The results speak for themselves.
{{table}}
Speed varies by complexity. Simple tasks like adding a component finish quickly. Larger operations like generating a full power management system take longer, but are still dramatically faster than before.
We also shipped several improvements alongside the new agent, all focused on the same goal: helping you build hardware faster.
This release focused on speed and correctness, but we're not stopping here. Up next: even better verification loops, more tools for organizing complex projects, continued schematic legibility improvements, and further Auto-Layout upgrades. Lots more to come.
Log in and run a prompt you've tried before. You'll feel the difference immediately.
{{login-to-flux}}
Flux helps you design with live pricing and stock data, using AI to find in-stock parts and fast replacements before your BOM breaks.
Flux takes a different approach. Instead of treating pricing and availability as a post-design concern, Flux keeps live supply data connected to your project as you work. Your project becomes a living document that stays aligned with the supply chain, surfacing constraints early—when decisions are still flexible and changes are cheap.
When you browse and select parts in the part library, Flux shows pricing and availability so you can spot sourcing constraints early. The Part Library panel is collapsed by default—expand it to see full pricing and availability details. You can also filter by stock status using the cart icon to show only available components.
Ask Flux AI to find parts that are in stock—it searches real-time supply chain data and understands your full project context. Instead of manually checking distributor websites, you get parts from the library that match your requirements and constraints.
Example prompt:
"I need a 16-bit ADC with at least 1 MSPS sampling rate for a battery monitoring application. Find what’s available within 2 weeks?"
Ask Flux AI to find a replacement that's in stock. It understands your full project context, including what the part connects to, how you're using it, and your design requirements and constraints, and suggests parts with similar packages and specifications.
It prioritizes availability over minor price differences and recommends parts already in the library, so you don't have to build them from scratch. Once you select a replacement, Flux AI can automatically drop it onto the canvas and wire it up for you.
Example prompt:
"Can you find me a cheaper replacement for U2?"
To check availability for a part, click on it in your design to open the inspector panel on the right. Scroll to the bottom, and you'll see real-time stock levels across multiple distributors—Arrow, Mouser, DigiKey, LCSC, Verical, and TME. This gives you a clear picture of whether a part is widely available or at risk of supply chain issues. If the part isn't in Flux's library, the system can search the broader internet to find availability data.
Note: You'll need a manufacturer part number (MPN) defined in the MPN property for generic parts.
Supply chain constraints don't go away once you've finalized your design—they just become more expensive to fix. The earlier you catch them, the more options you have.
Start treating sourcing as a design constraint, not a procurement problem. Check availability when you select parts. Let Flux AI flag risky components before you commit to a layout. And when something goes out of stock, find alternatives while you still have room to adjust.
The tools are already in your workflow. Use them before the BOM forces your hand.
{{try-it-in-flux}}
