* **We cannot generate a schematic for you.** \ Quilter only creates layouts from complete schematics. If you need assistance generating your schematic, consider using a tool like [Flux.ai](https://flux.ai), [CELUS](https://www.celus.io/), or [Circuit Mind](https://www.circuitmind.io/). ### Guides for Getting the Best Results #### [Placement Guide](/guides/placement-guide) # Why we're building Quilter An overview of Quilter’s mission to streamline PCB layout through physics-driven automation, enabling engineers to rapidly explore, iterate, and optimize their designs. Quilter was founded by [an electrical engineer](https://www.linkedin.com/in/sergiynesterenko/) with a simple goal: to help engineers save valuable time by automating circuit board layout. ### More time exploring, less time implementing PCB layout is tedious and time-consuming. At Quilter, we envision a world where engineers spend more time exploring ideas and less time implementing them in CAD tools. A world where there are virtually no barriers or latency between documenting the requirements of a new physical product, and beginning to explore the tradeoffs and possibilities that could make it a reality. Our vision is for Quilter to empower engineers and creators to rapidly explore ambitious ideas, understand interconnected constraints, and quickly discover optimal solutions. Quilter is purpose-built to facilitate software-driven creation and iteration, freeing engineers from the burden of manually specifying exactly how a board should be laid out. ### Physics as a north star Most EEs know that just because a PCB design is *complete* doesn't mean it's going to *work*. PCB design fundamentally revolves around physics—electromagnetic behavior, current flow, thermal management, and timing constraints define a board’s success. At Quilter, we aim to anchor every layout decision in these physical realities, guiding our automated processes to generate, evaluate, and improve designs accordingly. Because humans can't mentally simulate complex interactions like crosstalk or impedance, they often design conservatively, introducing inefficiencies such as oversized boards, unnecessary routing margins, or overly cautious constraints. Quilter combines reinforcement learning with rigorous physics-based rule checks, enabling it to push beyond human limitations to continuously optimize boards for performance, density, and manufacturability. We're not only pursuing faster PCB layouts—we’re striving for better ones. Our goal is enable Quilter to create leaner, higher-performing boards precisely tailored to their functional requirements, eliminating manual guesswork and iterative redesigns. While Quilter is significantly faster, it is continually evolving to match and eventually surpass the optimization skills of expert human designers. For details on our current progress and capabilities, see [What Quilter does well](/about-quilter/what-quilter-does-well). ### Iterate early & often Ironically, it's often faster and cheaper to fabricate and ship a circuit board from halfway around the world than it is to manually design it in the first place. Slow, manual layout processes mean that failed design iterations can significantly delay R\&D timelines, causing many teams to adopt overly cautious, linear approaches that limit the ability to learn by *building*. Quilter's objective is to transform this approach with the help of automation. By dramatically accelerating PCB layout, Quilter enables engineers to prototype immediately, iterate frequently, and rapidly refine their designs. Instead of cautiously committing to one design, teams can quickly test multiple candidates, identify issues early, rapidly adapt to real-world constraints, and evolve their solutions faster. The result is a more agile development cycle that emphasizes rapid learning and continuous improvement. Engineers using Quilter don’t just build faster; they build smarter, gaining deeper insights into design tradeoffs, uncovering unexpected solutions, and delivering superior products to market in significantly less time. # Why should I use Quilter? Key reasons to adopt Quilter’s AI-powered PCB layout automation, highlighting faster time-to-market, efficient iterative design, reduced errors, and optimized use of engineering talent. > Quilter can't design *every* PCB, but if it *can* design it, Quilter should. We've spoken with dozens of world-class hardware design teams and have never encountered an organization where PCB layout wasn't a bottleneck. The reality is that there are far too few experienced layout engineers to meet the rapidly growing demand for PCBs. The best organizations are experimenting with new automation and AI-powered tools to transform their cultures and become faster, more efficient, and more effective than ever. There are numerous reasons to start adopting AI-powered automation tools like Quilter; here are a few of the most common ones: ### Get to market faster Quilter dramatically reduces PCB design cycle times by automating the layout process. Traditional manual layouts can take weeks, but Quilter generates optimized design candidates within hours. Accelerating your PCB design cycles enables you to get your products to market faster, seize opportunities ahead of competitors, and respond swiftly to customer feedback and emerging market demands. ### Improve designs through iteration Quilter’s automation allows engineers to quickly and easily test multiple layout iterations, which is often impractical in manual workflows due to time constraints. With Quilter, you can rapidly explore design alternatives and trade-offs, leading to innovative solutions and higher-performing boards. More experimentation facilitates the discovery of the best design outcomes, rather than settling for the first viable option. ### Protect your best engineers Experienced PCB layout engineers are a scarce and valuable resource. Quilter offloads tedious, repetitive tasks so your most skilled engineers can focus on challenging, high-impact design decisions that truly benefit your products. By automating mundane aspects of layout, you safeguard and maximize your team’s most valuable engineering expertise. ### Eliminate costly mistakes Quilter’s physics-based rule checks and automated design processes significantly reduce the human error inherent in manual layouts. Every generated candidate undergoes rigorous validation to ensure compliance with real-world constraints, drastically lowering the likelihood of costly design errors and re-spins. Spending less time fixing mistakes means more resources are available for innovation and growth. ### Design and iterate faster Leveraging AI-driven automation, Quilter provides immediate design iterations without waiting days or weeks for manual updates. By quickly generating multiple layout options, teams can iterate rapidly, test assumptions frequently, and optimize designs efficiently. This AI-driven agility ensures continuous improvement throughout the product development process. # How does Quilter work? An overview of Quilter’s physics-driven approach to automated PCB layout, constraint handling, and validation. Quilter is different from all other ECAD automation solutions because: 1. **It understands good and bad physics**, eliminating the need for you to program tedious design rules to get good results 2. **It explores multiple stack-ups simultaneousl**y and customizes each candidate for the stack-up it's designing with 3. **It validates functionality with Physics Rule Checks (PRCs)** to ensure that designs are likely to function as intended. ### How Quilter is different from traditional ECAD tools Quilter is different from automation features in an ECAD tool in a few important ways:
1. **You specify constraints at the physics level, not the rules level.** \ Most ECAD tools—even those with automation features—do not recognize the fundamental physics constraints present within a schematic. This means that humans must manually define the geometric rules needed to satisfy the physics requirements.\ \ Working with Quilter is closer to working with a layout engineer. Our goal is to understand the constraints at the physics level, allowing Quilter to calculate and apply the appropriate geometric constraints for every design variant (and stack-up) that it investigates.
# What Quilter does well A concise summary of Quilter’s recommended applications and optimal design parameters. Quilter can do a lot, but there are many things it can't do yet. For a complete list of supported physics constraints, see [Physics Constraints](/physics-constraints/overview). ### Recommended applications Right now, Quilter can't typically design or optimize boards as well as skilled humans. Quilter's main advantage is speed—it designs boards much faster than humans, can create multiple layouts at once (for different stack-ups, fabricators, and schematic versions), and can thoroughly test whether a design will work as expected through Physics Rule Checks. Think of Quilter as a junior EE that can support and supplement your experienced layout engineers. (see [Why should I use Quilter?](/about-quilter/why-should-i-use-quilter)). This makes Quilter well-suited to tackle the following types of designs: #### Research & Development * **IC Evaluation Boards:** Speed up lab testing with early hardware access * **Design Validation:** Shorten functional validation cycles * **Connector Breakouts & Harnesses:** Quick turnaround for signal access and subsystem testing #### Testing & Automation * **Test Fixtures and Harnesses:** Automate time-consuming internal board testing * **Environmental Testing:** Create multi-channel IC test and validation boards #### Time-Sensitive Layouts * **Schematic-to-Test Workflow:** Skip the layout step in test board development * **Agile Prototyping:** Iterate quickly with zero layout delay * **Low-Complexity Designs:** Free up engineering time and avoid layout bottlenecks ### Recommended design parameters We currently recommend Quilter for the following designs: #### General specifications * **<5,000 pins:** Quilter is most likely to generate successful candidates for designs with 5,000 pins or fewer. * **Low to medium density designs:** Quilter cannot optimize designs better than humans, so very high-density designs (>20% pin density) are best handled manually. #### High-speed digital designs * **Signals < 6GHz:** Quilter uses quasi-static approximations to calculate design specifications for impedance-controlled signals, which may not be accurate above 6GHz. #### **Low voltage** * **Low-voltage designs (48V or less):** Quilter does not currently support the required physics constraints to manage dielectric breakdown, creepage and arcing for high-voltage designs. We recommend manually separating high-voltage signals before submitting them to Quilter. #### **Low current** * **Low-current designs (10A or less):** Quilter is not (yet) designed for very high current applications. When using high current designs, we recommend using pours to to route the net (see "attempt power pour" in the high power comprehension).
# FAQ ### Contents [What's the best way to evaluate Quilter?](#whats-the-best-way-to-evaluate-quilter) [Is Quilter a copilot?](#is-quilter-a-copilot) [How is Quilter different from an autorouter?](#how-is-quilter-different-from-an-autorouter) [How does Quilter use AI to generate designs?](#how-does-quilter-use-ai-to-generate-designs) [How is Quilter different from other AI design tools?](#how-is-quilter-different-from-other-ai-design-tools) [Is it hard to learn to use Quilter?](#is-it-hard-to-learn-to-use-quilter) [Can Quilter generate or validate schematics?](#can-quilter-generate-or-validate-schematics) [Can Quilter manage component libraries and footprints?](#can-quilter-manage-component-libraries-and-footprints) [Can Quilter implement reference designs from datasheets?](#can-quilter-implement-reference-designs-from-datasheets) [How many layers can Quilter support?](#how-many-layers-can-quilter-support) [How does Quilter handle reference designators?](#how-does-quilter-handle-reference-designators) [Do I have to enter physics constraints manually?](#do-i-have-to-enter-physics-constraints-manually) [Does Quilter train on my designs?](#does-quilter-train-on-my-designs) [Do you support on-premise deployments?](#do-you-support-on-premise-deployments) [Where is Quilter's team located?](#where-is-quilters-team-located) [How can I delete my account?](#how-can-i-delete-my-account) [Adding or removing team members](#adding-or-removing-team-members) [How can I monitor my enterprise team's usage?](#how-can-i-monitor-my-enterprise-teams-usage) ### What’s the best way to evaluate Quilter? The best way to evaluate Quilter is by starting with a known-good design you’ve previously completed. By submitting your existing schematic and board files, you can quickly compare Quilter’s output to your original layout, clearly benchmarking improvements in layout speed, manufacturability, and quality. \ Quilter offers both a free version and an enterprise version, each designed to meet different user needs. The free version allows users to explore its core functionalities, while the enterprise version includes advanced features such as a commercial license and enhanced data privacy measures.\ With this approach, you can easily validate Quilter’s capabilities and see firsthand the time savings and layout improvements it provides. Quilter also offers free evaluation support and customized evaluation programs for enterprise customers to ensure a seamless and productive experience.
The enterprise version offers additional benefits, including a commercial license for intellectual property generated using Quilter and enhanced data privacy, ensuring that uploaded designs are not used for training data.
**To start your evaluation, you can either:** * Create a Non-Commercial Account to evaluate the free version by submitting designs to our multi-tenant application at [https://app.quilter.ai](https://app.quilter.ai/) * [Request a Demo](https://www.quilter.ai/demo) to explore the enterprise version and access support through our White Glove Evaluation Program. ### Is Quilter a copilot? No — Quilter is not a copilot in the traditional sense. While many tools aim to assist human designers and incrementally improve their efficiency, Quilter is built for full automation. It doesn’t require a layout engineer to manually guide or interact with it during the design process. Instead of serving as a productivity booster for your top layout engineers, Quilter generates complete board layouts on its own, freeing up human resources for tasks like system-level architecture or design for manufacturing. This makes it especially valuable in R\&D environments where quick iteration on low-volume boards is essential and layout resources are limited. That said, we understand that no model is perfect. When needed, Quilter offers mechanisms to review and modify its output, but its main goal is to eliminate the need for manual layout from the start. ### How is Quilter different from an autorouter? Quilter is more than just an autorouter — it’s a complete PCB layout engine. Unlike traditional autorouters, such as the one in Altium, which only focus on routing traces and often require manual cleanup for complex designs, Quilter handles the entire layout process. This includes placement, selecting stack-ups, defining pour strategies, and checking constraints based on physical properties— all seamlessly integrated into the workflow. Instead of making you micromanage things like widths, separations, and impedance rules, Quilter asks for a higher-level understanding (like “this net is 50Ω impedance-controlled”) and takes care of the rest automatically. This leads to more accurate, manufacturable designs — especially for complex, high-pin-count boards like DDR4 memory systems. Most importantly, we strive for 100% completion. Autorouters often give up around 70–90%, leaving designers to sort out messy, unusable partial results. With Quilter, a design that doesn’t fully route is considered a failure. That focus on full automation, combined with physics-aware layout and rapid product evolution, sets Quilter apart. ### How does Quilter use AI to generate designs? Quilter uses a physics-driven AI approach called reinforcement learning to create PCB layouts — similar to how AlphaGo learned to play Go by playing against itself repeatedly. Instead of relying on human-designed boards as examples, Quilter explores numerous layout possibilities on its own, evaluating each with detailed physics assessments we call Physics Rule Checks (PRCs). Over time, this self-guided approach lets Quilter continuously improve and adapt, optimizing designs based on real-world physics considerations like thermal management, EMI, impedance control, and more. Right now, our focus is on quickly generating designs for rapid real-world testing, and we’ll keep expanding the complexity and depth of physics feedback built directly into Quilter’s automated layout process. ### How is Quilter different from other AI design tools? Quilter uniquely integrates with your existing tools and delivers full PCB layout automation using physics-driven reinforcement learning. Quilter sets itself apart from other AI-driven ECAD tools with three key advantages: seamless integration, a sole focus on layout automation, and integrated physics modeling. First, Quilter integrates smoothly with your existing design tools, so you don’t have to switch software or disrupt your workflow to use its capabilities. Second, Quilter focuses exclusively on PCB layout automation, whereas most competing tools prioritize automating or streamlining schematic capture. Quilter tackles the challenges of component placement, impedance control, routing, and design-rule validation head-on. Lastly, unlike other AI approaches that learn by mimicking human-designed boards, Quilter uses physics-based reinforcement learning. It autonomously generates and evaluates layouts through detailed physics simulations, ensuring each design is optimized according to fundamental electrical and manufacturing principles, not just replicating previous human-created patterns. ### Is it hard to learn to use Quilter? Engineers typically submit their first design in Quilter within minutes, making it quick and easy to learn. Quilter doesn't offer a full CAD interface, but rather replicates the conversation between an electrical engineer and a layout engineer when starting a new design. It's designed to be intuitive and easy to use, with a super short learning curve. Most engineers submit their first design within 5–10 minutes of signing up. The intuitive interface and automated processes mean you don’t need extensive training to get started. As you use Quilter, you’ll quickly get familiar with its capabilities and configurations. Typically, engineers become proficient after just a few submissions, rapidly iterating to refine layouts and optimize results. ### Can Quilter generate or validate schematics? No — Quilter does not generate or verify schematics. It exclusively focuses on automating the PCB layout process. Quilter assumes the schematic you provide is correct, using it as the starting point for layout generation. By automating layout tasks, Quilter significantly reduces the time needed to produce prototypes, allowing your team to quickly identify schematic issues through real-world testing and iterations. However, schematic validation and creation remain outside Quilter’s current scope. ### Can Quilter manage component libraries and footprints? Quilter doesn't manage or create component libraries and footprints itself. Instead, it relies on the libraries and footprints you already have in your current ECAD tools. When you upload your schematic and board files, Quilter keeps and uses the footprints exactly as you defined them. This approach ensures consistent, trusted component definitions and reduces the risk of component mismatch or errors in your designs. Quilter focuses on placement and routing, leaving you in full control of your library standards and component quality. ### Can Quilter implement reference designs from datasheets? Quilter does not directly import or automatically implement reference designs from component datasheets. However, you can manually place and route critical reference layouts — such as switching regulators or RF circuits — exactly as specified by the datasheet, and Quilter will fully respect and preserve your layout decisions. Any manual placements or routing you provide remain untouched during Quilter’s automated layout process. Quilter then completes the rest of the design around your predefined reference areas, seamlessly integrating your precise manual implementations with automated routing. ### How many layers can Quilter support? Quilter currently supports a range of PCB layouts, from basic 2-layer designs to complex multilayer stack-ups with 10 layers or more. In reality, adding extra layers often simplifies automated layout for Quilter, as they provide more space for routing and power planes. There's no fixed upper limit — Quilter can handle extremely complex multilayer stack-ups defined in your manufacturing profile, giving you the flexibility to meet a wide variety of design needs. ### How does Quilter handle reference designators? Quilter does not currently handle or optimize silkscreen placement. While component placements include associated silkscreen outlines, Quilter does not automatically resolve silkscreen overlaps or positioning issues. When Quilter places components, it maintains the same relative position of the silkscreen reference designators, which can sometimes lead to silkscreen collisions. After Quilter generates the PCB layout, you may need to manually adjust silkscreen markings within your ECAD tool to ensure readability, compliance, and manufacturability. Improved silkscreen handling is planned for future updates but isn’t available today. ### Do I have to enter physics constraints manually? No — Quilter automatically detects and extracts key physics constraints directly from your schematic. It identifies constraints such as impedance-controlled signals, differential pairs, length matching, high-current nets, and sensitive circuits through its Circuit Comprehension interface. After Quilter extracts these constraints, you review and verify them for accuracy. You can manually adjust or add additional constraints if needed, ensuring the layout meets your precise design requirements. ### Does Quilter train on my designs? No — Quilter does not train on any **paying customer** designs or human-created layouts. We never collect or use **paying customer** data to train or improve our models. Your schematic and constraints are used only to generate your board layout, and once the job is complete, that data is discarded from the training process. Instead of learning from human examples, Quilter primarily uses a self-play approach similar to AlphaGo. The system explores many layout possibilities on its own and evaluates them with physics simulations to learn from the outcomes. This method allows us to avoid the limitations of human-designed training data and scale learning through simulation, not customer input. This is both a core privacy promise and a technical strategy—your IP remains private, and Quilter’s performance continues to improve without relying on customer-submitted designs. {% hint style="info" %} Training policy for our Non-Commercial (Free) Tier:\ Keep in mind that our Terms of Use for Quilter's Non-Commercial Tier, which is free for our users, permit training on both users' direct inputs and synthetic training data generated from those inputs. For more information on the Non-Commercial Tier Terms of Use, visit [quilter.ai/terms](https://quilter.ai/terms) {% endhint %} ### Do you support on-premise deployments? Yes — Quilter supports multiple deployment options, including fully on-premise setups. You can choose to deploy Quilter: * In our standard hosted cloud environment. * Through an isolated hosted deployment on AWS or GovCloud. * Directly on-premise within your private cloud infrastructure. For organizations with strict IP protection needs — such as aerospace, defense (e.g., ITAR compliance), or highly secretive consumer electronics firms — deploying Quilter on-premise ensures your design data stays within your secure network. We suggest initially testing Quilter with non-sensitive designs using our hosted environments to simplify the setup. When required, an on-premise installation is fully supported and can be easily deployed on your existing Kubernetes or private cloud environment. #### What are the infrastructure requirements to host Quilter on-premise? Quilter deploys into your own Kubernetes cluster as a Helm chart. The platform creates compute jobs for component placement and trace routing, scaling resource usage based on board complexity and desired throughput. To run Quilter self-hosted, you'll need a Kubernetes cluster with access to GPU and general-purpose CPU capacity. GPU nodes should provide modern NVIDIA GPUs with at least 16 GB VRAM. CPU and GPU requirements scale with workload — fewer resources mean longer processing times, but the platform adapts to your available capacity. Updates and upgrades are delivered as new Helm chart versions, deployed into your cluster on your own schedule. ### Where is Quilter's team located? Our team is distributed across the United States, with significant presence in California (including Los Angeles and the Bay Area) as well as other regions nationwide. Our team includes experts across multiple disciplines: * Electrical Engineering: Engineers with deep expertise in PCB design and industry-leading ECAD tools. * AI & Machine Learning: Specialists focused on applying reinforcement learning and simulation-driven methods to PCB layout automation. * Computational Geometry: Experts skilled in geometric optimization algorithms essential for creating efficient, manufacturable layouts. This diverse expertise allows Quilter to provide innovative automation solutions that blend industry best practices with advanced computational techniques. ### How can I delete my account? We understand you may need to delete your account and data. Whether you are no longer using our services or simply want to start fresh, we want to make the process as easy as possible for you. 1. Send Us an Email\ To start deleting your Quilter account and data, please email our team at
2. **Quilter integrates seamlessly with your current CAD tools.** \ It works directly with both new and existing design files created within your existing CAD tools. This means you can skip using SPECCTRA, ODB, or third-party file converters. Quilter reads and writes to your design files just like your layout engineers do.
3. **Whatever you start, Quilter will finish.**\ Quilter works by placing and routing any components left outside your board outline to design your PCB to 100%. This means that you can place or route sensitive components or signals before submitting to Quilter, and it will try to complete the design for you. ### How Quilter evaluates layout candidates There are three key factors that Quilter considers when generating and recommending layout candidates:
1. **Completeness**\ We measure "routing completion" for each candidate as the percentage of unrouted pins that have been successfully implemented. Quilter's objective is to place and route all designs to 100%. 2. **Manufacturability**\ Quilter's objective is to design using fabrication rules that are fully supported by the specified fabricator, and contain 0 DRC violations. 3. **Physics**\ Quilter uses our "Physics Rule Checks" (PRCs) framework to ensure that the sensitive signals and physics constraints you specified during Circuit Comprehension are properly implemented and likely to function as expected.
### Quilter's design workflow Quilter simplifies the PCB design process into clear, straightforward steps: prepare your inputs, define your circuit comprehensions and parameters, review generated design candidates, and download your final layouts for fabrication. {% stepper %} {% step %} #### [Prepare your input board file](/using-quilter/prepare-your-input-board-file) Quilter requires a schematic and "starter" board file that includes a valid board outline, netlist, and component footprints. Leave the components you want Quilter to place and route outside of the board outline. {% endstep %} {% step %} #### [Upload your design files](/using-quilter/upload-your-design-files) Upload your design files to Quilter's web application. We will parse your board file to ensure we can correctly read your board objects, and process your schematic to automatically detect physics constraints. {% endstep %} {% step %} #### [Select your stackup](/using-quilter/select-your-stackup) Provide Quilter with details about your layout preferences, such as your desired fabricator, the number of layers, and the fabrication tolerances. {% endstep %} {% step %} #### [Define physics comprehensions](/using-quilter/define-physics-comprehensions) Review, validate, and add or remove physics constraints in a step known as Circuit Comprehension. Quilter utilizes this information to ensure that sensitive design features are implemented correctly and to provide corresponding Physics Rule Checks that evaluate and recommend layouts. {% endstep %} {% step %} #### [Submit your layout job](/using-quilter/submit-your-layout-job) Submit your job! Quilter will explore hundreds of individual design variations with different stack-ups and fabrication tolerances, validating Physics Rule Checks (PRCs) for every constraint specified in Circuit Comprehension. {% endstep %} {% step %} #### [Review layout candidates](/using-quilter/review-layout-candidates) Review the recommended layout candidates from Quilter and choose your preferred option. Download your chosen candidate back into your original CAD file format for a final review. {% endstep %} {% endstepper %} ### Quilter's technical submission review process The steps outlined here are the current actions required to prepare a board for Quilter and a guide to successful submission to Quilter.
1. Open Schematic to check the following: 1. Logical Complete Circuits on Each Schematic Page 2. Net Class Definitions 3. Bypass Cap ID - Explicit Assignment 2. Open board file 1. Import changes from schematic into board file. 2. DRC Rules Review/Run 3. Draw Rooms/Manage Floor Plan 3. Upload to Quilter 1. Manufacturing Guidelines 1. Confirm Stackup/Layers Perferred 2. Trace and Space Guidance 3. CM and EMS Specs/Templates 2. Physics Checks 1. Verify Bypass Capacitors - validate 2. Verify Differential Pair 3. Verify Crystals 4. Power Nets - add by net class, discuss power pours 5. Net Widths - are there specific widths 6. Impedance Control - add by net class 7. Verify Switching Converters 8. Verify Rooms 9. Discuss Preserve Pours 4. Submit and Run. # Design your schematic Concise guidelines for preparing schematics compatible with Quilter, including supported CAD platforms and design best practices. Quilter's primary function is to design PCBs from your existing schematic. So, **before you can ask Quilter to generate your PCB, you need to have already designed your schematic.** Here are a few things to know when designing your schematic:
1. **Supported CAD platforms:** \ Quilter is currently compatible with Altium, KiCAD, Cadence Allegro, and Siemens Xpedition.
2. **Use native object classes whenever possible:** \ Whenever possible, use supported object classes to help identify important signals such as power nets, differential pairs, and important net classes. This will facilitate Quilter's automatic detection of these constraints during Circuit Comprehension.
3. **Validate your design before submitting:** \ Quilter's objective is to faithfully represent the schematic that you provide; we do not automatically verify that your design is free from errors. Before submitting to Quilter, be sure to review your schematic as if you were designing the layout yourself. {% hint style="warning" %} **Multi-channel designs**\ Quilter can parse hierarchical schematics, but currently does not support symmetrical layout for multi-channel designs. {% endhint %} # Prepare your input board file Instructions for creating an input board file for Quilter, covering required elements, recommended constraints, and optional parameters. The input board file is the most crucial input to Quilter, defining the degrees of freedom that it can explore when completing your layout job. Quilter comprehends the existing layout objects in your PCB files, including stack-ups, design rules, keepouts, pours, component footprints, and more. All design elements within the user-defined board outline (pre-placed components, routed traces, copper pours, rooms, etc.) can be designated as fixed constraints and will not be modified by Quilter during layout. You can find more information on each of the design parameters described below in the [Design Parameters](/design-parameters/overview) section of our documentation.
### Required design parameters Here are the required design parameters for all layout jobs. Make sure to include them in the board file you upload to Quilter:
* **Board Outline**\ You need to define a single valid board outline for Quilter to work with. Currently, Quilter can't define or resize the board outline for you, so you must do it yourself. To ensure Quilter recognizes the outline, define it on a specific layer:
* In **Altium,** use **Mechanical Layer 1 (Mechanical 1)** * In **KiCAD**, use the **Edge.cuts** layer {% hint style="info" %} Quilter only supports one closed board outline. Components with keepouts or other polygon zones defined on the same layer as the board outline can confuse Quilter's parser. {% endhint %} * **Component Footprints**\ Quilter doesn't manage your component footprints, so you need to pre-load them into your board file before submitting. Quilter can't automatically try or choose from multiple footprints or packages for the same component. * **Netlist**\ Lastly, Quilter requires a valid netlist that matches the uploaded schematic. For the best results, please ensure your netlist is up to date with the latest version of your schematic.
### Recommended design parameters Here are some design parameters that aren't strictly required, but are recommended for most layout jobs:
* **Ground and power layer names**\ Quilter requires that ground layers be named "ground" or "gnd", and power be named "power" or "pwr" if you want those to be detected and used * **Pre-placing components (like connectors)**\ Quilter won't move any components you pre-place within the board outline, and will automatically route the rest. {% hint style="warning" %} Quilter can't automatically distinguish connectors from other unplaced components, we strongly recommend pre-placing them to prevent your USB connector from ending up in the center of your board. {% endhint %} * **Not-yet-supported physics constraints**\ Quilter can't handle all physics constraints in all designs yet. If your physics constraint isn't listed in Circuit Comprehension, Quilter won't give it special attention and will route it like a generic low-voltage, low-speed signal. \ \ For this reason, we recommend pre-placing and pre-routing any sensitive design elements that Quilter doesn't support yet (like trace antennas or high-speed signals over 6GHz).
### Optional design parameters * **Keepouts**\ You can define placement or routing keepouts that Quilter will respect during the design generation process. Read more in [Keepouts](/design-parameters/keepouts). * **Copper pours**\ Quilter can preserve and utilize pre-defined pours for external (currently supported) and internal (coming soon) copper layers. Read more in [Preserved pours](/design-parameters/preserved-pours). * **Placement regions**\ Quilter supports the use of placement regions ("Rooms" in Altium) to constrain component placement. Read more in [Placement regions](/design-parameters/placement-regions). ### Stackups from input files * **Custom stackups**\ You can specify custom stackups in your ECAD files that Quilter will use when generating candidates. Read more in [Stackups](/design-parameters/stackups). * **Design rules**\ You can also specify custom fabrication rules in your input file that Quilter will use when generating candidates. Read more in [Fabricator constraints](/using-quilter/fabricator-constraints).
{% hint style="info" %} The fewer design parameters you lock down within your input file, the more flexibility you allow Quilter to explore. If Quilter fails to generate a fully complete candidate for your layout job, try relaxing design parameters in your input board file. {% endhint %} ### Exporting files from Cadence Allegro Download the script from the Upload files page, unzip, and follow instructions in the README.md file. These instructions are constantly updated as the script is updated.
File preview page
| Constraint | Details | Automatic? |
|---|---|---|
| /pages/6n6pBLMX9LH3mW3zGWDT | Design high-current nets as traces with a specified width or as copper pours. | Automatically detected |
| /pages/FQkEcqQF14sKwWxhqUWU | Generate differential pairs with controlled lengths and impedances for high-speed digital signals. | Automatically detected |
| /pages/PYz2sZ6jr6LwiNiNHOhF | Impedance-controlled nets for RF nets or other fast, long, or sensitive traces. | Manual |
| /pages/AWyphmkmhKFzQOw9o2MC (coming soon) | Length matching for timing-sensitive interfaces such as DDR memory | Manual |
| Constraint | Details | Automatic? |
|---|---|---|
| /pages/UoFdbNAFEuvp1pOFyMPf | Position oscillators close to their drivers to minimize phase noise and startup issues. | Automatically detected |
| /pages/W90IOb5Uq46rHkqVwEGQ | Ensure tight ground return loops for input and output paths to reduce EMI and voltage ripple. | Automatically detected |
| /pages/K93E9jzwkH8P11hi7pjq | Ensure a stable, low-impedance signal path for power pins. | Automatically detected |
| Constraint | Details | Automatic? |
|---|---|---|
| /pages/6n6pBLMX9LH3mW3zGWDT | Design high-current nets as traces with a specified width or as copper pours. | Automatically detected |
| /pages/FQkEcqQF14sKwWxhqUWU | Generate differential pairs with controlled lengths and impedances for high-speed digital signals. | Automatically detected |
| /pages/PYz2sZ6jr6LwiNiNHOhF | Impedance-controlled nets for RF nets or other fast, long, or sensitive traces. | Manual |
| /pages/AWyphmkmhKFzQOw9o2MC (coming soon) | Length matching for timing-sensitive interfaces such as DDR memory | Manual |
| Constraint | Details | Automatic? |
|---|---|---|
| /pages/UoFdbNAFEuvp1pOFyMPf | Position oscillators close to their drivers to minimize phase noise and startup issues. | Automatically detected |
| /pages/W90IOb5Uq46rHkqVwEGQ | Ensure tight ground return loops for input and output paths to reduce EMI and voltage ripple. | Automatically detected |
| /pages/K93E9jzwkH8P11hi7pjq | Ensure a stable, low-impedance signal path for power pins. | Automatically detected |
| Suffix | Description | Example |
|---|---|---|
+ / – | Plus / Minus | TX+ and TX- |
A / B | A / B | SSTXA and SSTXB |
P / M | Plus / Minus | RFoutP and RFoutM (last character) USB_DPX and USB_DMX (second-to-last character) |
P / N | Positive / Negative | DP and DN |
t / c | True / Complement | ddr0_dqs_t and ddr0_dqs_c |
What is the highest frequency Quilter can handle?
Quilter's impedance control calculations are accurate and recommended for signals up to 6GHz.Can Quilter handle multiple bypass capacitors for a single IC?
Yes, Quilter can identify and optimize one-to-many relationships between ICs and their bypass capacitors, ensuring effective decoupling across different frequency ranges.How does Quilter decide where to place bypass capacitors?
Quilter strategically places smaller capacitors near high-current voltage sinks to minimize impedance and stabilize power delivery. The algorithm reduces trace lengths and via counts to lower parasitic effects in the decoupling network.Can I override Quilter’s automatic placements?
Yes, you can manually adjust or pre-place bypass capacitors in your input file if you have specific design requirements.Example PRC result for a Bypass Capacitor constraint
| Parameter | Description | Preference | Requirement |
|---|---|---|---|
| /pages/UAbcuyp5se6YcH5hjtm4 | The PCB manufacturer that a specific layout candidate (stackup and fabrication ruleset) is designed for. | ✅ Filter by fabricator | ✅ Enteprise customers only |
| /pages/ZbYbLZzQ3agYsIweMCEU | The stackup that Quilter uses when generating your candidate, including layer count, copper weight, material properties, and more. | ✅ Layer count only | ✅ Stackup from input files |
| /pages/DjgbihBmHtIOyB3xskYJ | Basic design rules that ensure your board can be manufactured without issue – trace, space, drill, via, edge clearances, etc | ✅ Trace and space | ✅ Design rules from input files |
| Parameter | Description | Preference | Requirement |
|---|---|---|---|
| /pages/EcoVcR3CKIcqpYqjB5h7 | Lock the location of location-sensitive components so Quilter can't modify it. | ⬇️ Use "placement regions" | ✅ Place within board outline in input file |
| /pages/Vvl4M5yhRVPlMSzhQ6hW | Restrict Quilter's placement of unplaced components to a designated area within your board outline. | ❌ Placement regions are always respected | ✅ Add to input board file |
| /pages/hXVfJU2UbeXSaGsgMikL | Limit placement to one side of the PCB. | ✅ Filter for single-sided designs. | ⬆️ Use "placement regions" |
| Parameter | Description | Preference | Requirement |
|---|---|---|---|
| /pages/Gi93ywL7IY5D7fsi13ho | Lock the routing path of sensitive signals. | ❌ Pre-routed traces are always preserved | ✅ Leave within board outline in input file |
| /pages/8uMnhPLSzjJHr92fRwhs | Preserve existing copper pours from your input pile for Quilter to use when generating candidates. | ❌ Preserved pours are always respected | ✅ "Lock" pours you want to preserve in input ful |
| /pages/YwcOS2w5Bv358iaMGmbm | Prevent Quilter from routing traces through specific geometric areas within your design. | ❌ Keepouts are always respected | ✅ Add keepout to your input file |
| /pages/avcHOKpvovo3AuY05Q6W | Manually specify net widths for individual nets or net classes in your design. | ❌ Net widths are always respected | ✅ Specify "Net Width" in during job setup |
| Fabricator | Description | Location | Website |
|---|---|---|---|
| JLCPCB | High-volume, low-cost PCB manufacturer with rapid turnaround. | China | jlcpcb.com |
| MacroFab | North American contract manufacturer offering prototyping to production. | Houston, TX, USA | macrofab.com |
| OSH Park | Community-focused PCB prototyping service for small-batch orders. | Oregon, USA | oshpark.com |
| CircuitHub | Turnkey PCB assembly service integrated with online BOM sourcing. | Massachusetts, USA | circuithub.com |
| American Standard Circuits | Full-service PCB manufacturer specializing in advanced and RF designs. | West Chicago, IL, USA | asc-i.com |
| Fabrication Rules | Stackup: 2 Layer Standard | Stackup: 4-Layer Standard | Stackup: 6-Layer Standard | |
|---|---|---|---|---|
| Common_10_mil | • 10 mil trace/space • 12 mil drill | ✅ | ✅ | ✅ |
| Common_8_mil | • 8 mil trace/space • 12 mil drill | ✅ | ✅ | ✅ |
| Oshpark_2_Layer | • 6 mil trace/space • 10 mil drill | ✅ | ✅ | ✅ |
| Oshpark_4_Layer | • 5 mil trace/space • 10 mil drill | 🔴 Not supported by fabricator | ✅ | ✅ |
| Oshpark_6_Layer | • 5 mil trace/space • 8 mil drill | 🔴 Not supported by fabricator | 🔴 Not supported by fabricator | ✅ |
2. **Unsupported physics constraints**\ If Quilter doesn't currently support a physics constraint that demands precise or highly organized placement of components, you can manually position individual components or groups to ensure they're placed correctly.
3. **"Saving your progress"**\ When working with Quilter, you might find that you like certain elements of a layout candidate, but not the overall design. Once you've downloaded a candidate, you can choose to keep the routing and placements you like, remove the rest, and resubmit to Quilter to save your progress towards a fabrication-ready design. ### How to specify #### As a preference Components inside the board outline are locked and can't be moved or rotated by Quilter during compilation. We won't change pre-placed components, even if they stop Quilter from finishing a layout job successfully. If you wish to constrain component placement to pre-specified sides or areas within your board outline, see [Placement regions](/design-parameters/placement-regions). #### As a requirement Locking the position and rotation of a component is easy: just pre-place it within the board outline and upload your input file to Quilter. # Placement regions Explanation of Quilter’s Placement Regions, including creation methods in Altium and Cadence, component associations, and instructions for constraining component placement. ### Overview Placement Regions allow you to limit component placement by ensuring that components tied to the region are positioned within its geometric boundaries during compilation. To set up a Placement Region, define a polygon object in your native ECAD input file, place it so it overlaps the board outline, and link it to either the top or bottom layer. Once you've uploaded your input file, you can assign components to that Placement Region, which tells Quilter to place those parts within the region's boundary.
Placement Regions appear as dotted lines in the board preview.
Review and manually add / remove components associated to each placement region before submitting your layout job.
2. **Unsupported physics constraints**\ If Quilter doesn't yet support a physics constraint that requires precise or highly organized placement of components, you can manually pre-place individual components or groups to ensure they come out correctly.
3. **"Saving your progress"**\ When iterating with Quilter, you might find yourself liking parts of a layout candidate but not the entire design. After downloading a candidate, you can pick the elements you like, remove the rest, and resubmit to Quilter to save your progress and move closer to a fabrication-ready design. ### How to specify #### As a preference Quilter won't put a component in a placement region outside of that region, even if it blocks Quilter from finishing a layout job. #### As a requirement Define a placement region by following these steps for your CAD tool:
{% tabs %} {% tab title="In Altium" %} Quilter utilizes Altium's "[Rooms](https://www.altium.com/documentation/altium-designer/pcb-rooms?srsltid=AfmBOopok-8wYiEOu-I8Is33x2w8w9GmT9s60KumbmLIqzAMSkw2gBS4)" feature to define placement regions and associate components with those regions. To define a placement region for Quilter: 1. **Create a Room in Altium.** \ You can use any of the following methods: 1. Select the required command from the **Design » Rooms** submenu, then either interactively define the room shape (if you selected a **Place** command) or automatically create the room (if you selected a **Create** command). 2. Add a new **Room Definition** design constraint, edit the new room constraint, and click the **Define** button to interactively define the shape of the polygonal room. 3. Create a room based on a selected closed outline formed by a set of tracks or arcs using the **Tools » Convert » Create Room from Selected Primitives** command. 4. Automatically create rooms during schematic to PCB design synchronization. Learn more about [automatically generated rooms](https://www.altium.com/documentation/altium-designer/pcb-rooms?srsltid=AfmBOopok-8wYiEOu-I8Is33x2w8w9GmT9s60KumbmLIqzAMSkw2gBS4#created_during_schematic_to_pcb_design_synchronization) (including how to disable them).
2. **Save and upload your input file.** \ Quilter will automatically parse your input board file to extract the Rooms as placement regions and automatically associate components in that room with the corresponding placement region.
3. **Review your input file.** \ After uploading, you can inspect your input file to ensure that Quilter generated the placement regions correctly. Placement regions will be highlighted as dotted lines in the board preview.
4. **Review and approve associated components.** \ Components in the Room will be automatically associated with the corresponding placement region. You can add or remove components as you wish.
5. **Submit your layout job.** \ Once you're done, submit your layout job, and Quilter handles the rest. {% endtab %} {% tab title="In Cadence" %} Quick tutorial video for creating rooms in Cadence:\
If you have problems using Cadence using Parallels on a Mac, it may help to move your project into a folder like C:/Demos/my\_demo rather than on the Desktop. The desktop folder is a network-shared folder between Parallels Windows and native Mac and this can cause issues. {% endtab %} {% tab title="In KiCAD" %} Quilter utilizes KiCAD's "Rule Areas" feature to define placement regions. Components must be manually associated with placement regions after being imported into Quilter.
To define a placement region for Quilter: 1. **Create a Rule Area in KiCAD**\ Use the corresponding icon on the right-hand menu: 1. It must be associated with the top or bottom layer (usually `F.Cu` or ). 2. Define it as a "Keepout" and give it a recognizable name. 3. Deselect all keepout items. This indicates to Quilter that it is a placement region and not a keepout (which Quilter also supports).\ \
2. **Save and upload your input file**\ Quilter will automatically parse your input board file to extract the Rooms as placement regions and automatically associate components in that room with the corresponding placement region.
3. **Review your input file** \ After uploading, you can inspect your input file to ensure that Quilter generated the placement regions correctly. Placement regions will be highlighted as dotted lines in the board preview.
4. **Associate components with the placement region**\ Manually add components to the placement region using their reference designator.
5. **Submit your layout job**\ Once you're done, submit your layout job, and Quilter handles the rest. {% endtab %} {% endtabs %} # Single-sided placement Instructions for managing single-sided placement in Quilter, including automatic exploration, forcing double-sided layouts, and specifying single-sided constraints. ### Overview When exploring placement solutions, Quilter will automatically flip components between the top and bottom layers unless they are specifically associated with a placement region on that layer. For every layout job, **Quilter automatically tries to create some single-sided layout candidates** if it finds a valid placement solution that uses only one side. ### How to specify #### As a preference Quilter allows for preferential filtering by single-sided placement. To do this, go to the design parameters page and check the "Show single-sided layouts only" option. This will apply a filter during candidate review that you can remove if we don't generate any single-sided candidates. #### As a requirement Quilter will automatically try single-sided candidates first and only switch to double-sided placements if it can't find a valid solution. \ To make Quilter only explore single-sided placements, create [Placement regions](/design-parameters/placement-regions) that include all components and link them to the top layer of your PCB. # Pre-routed traces Instructions for managing pre-routed traces in Quilter, including reasons to pre-route, handling during layout, and specifying locked routing paths. ### Overview Quilter considers all traces and vias within the board boundary at the time of file upload to be "pre-placed". **As a foundational rule, Quilter does not alter the path or position of pre-placed traces and vias.** Quilter will not automatically delete unconnected or orphaned trace segments, so be sure to remove them from your input file before submission. During compilation, Quilter will strive to place and route all components that are not already routed. If a pre-routed trace segment is incomplete, Quilter will attempt to finish it during routing. {% hint style="warning" %} **Pre-routed traces on internal layers**\ If your input file includes pre-placed copper traces or pours on internal layers and you have *not* selected to preserve the stack-up in your input file, Quilter will delete them and generate new ones for each candidate and layer stack it explores. {% endhint %} ### Why should I pre-route traces? There are a couple of reasons to pre-route components:
1. **Unsupported physics constraints**\ If Quilter doesn't yet support a physics constraint that needs sensitive or highly organized signal routing, you can manually pre-place and route individual components to ensure they work correctly.
2. **"Saving your progress"**\ When iterating with Quilter, you might find that you like certain parts of a layout candidate, but not the overall design. Once you've downloaded a candidate, you can choose to keep the routing and placements you like, remove the rest, and resubmit to Quilter to save your progress toward a fabrication-ready design. ### How to specify Locking the path of a copper trace is easy – just pre-route it within the board outline and upload your input file to Quilter. # Preserved pours ### Overview Unlike [Pre-routed traces](/design-parameters/pre-routed-traces) Quilter **does not** automatically preserve copper pours that are present within the board boundary at the time of file upload. **Instead, Quilter only preserves copper pours that are represented in the "preserved pours" table during Circuit Comprehension.** All other pours on internal or external copper layers are deleted and regenerated by Quilter. Preserved pours can be added manually during job setup. In the near future, Quilter will automatically preserve pours that are marked as "locked" in the input file. {% hint style="warning" %} If you identify Preserved Pours on internal layers but choose not to preserve the stack-up when setting up your layout job, Quilter will still delete them and generate new internal layers for each layer stack and layout candidate it explores. {% endhint %} ### Why should I use preserved pours? There are a number of reasons to preserve copper pours:
1. **"Saving your progress".** If you are iterating with Quilter, you may find that you like elements of a layout candidate, but not the whole design. After downloading a candidate, you can choose to preserve the routing/placements you like, unplace and unroute the rest, and resubmit to Quilter to "save your progress" towards a fabrication-worthy design.
2. **Define advanced power planes for custom stack-ups.** Preserved pours will allow you to generate custom stackups that include custom and split power planes that supplement or replace the power planes recommended by Quilter. ### How to specify To specify a preserved pour, follow these instructions: 1. **Create the pour.** Create or identify an existing pour in your input board file that you wish to preserve during compilation. 1. If using KiCAD - make sure that the pour has a name. 2. **Upload your input file.** Save and upload the input file to Quilter. You can confirm that the pour was parsed correctly by toggling the "Pours" layer in the board preview. 3. **Add your "Preserved Pour".** Add your preserved pour by name to the "Preserved Pours" comprehension when setting up your layout job. # Keepouts Summary of using Keepouts in Quilter to restrict placement and routing areas, including common uses and how to specify them in your CAD tool. ### Overview Quilter integrates directly with keepouts defined in your CAD tool, so you can control where traces, vias, components, and pours are allowed. That's pretty much it – just add a keepout to your board, and we'll steer clear of it! ### Why should I use keepouts? Keepouts can help Quilter define the desired boundaries for design activity. Some common reasons to use keepouts include: 1. **Reserving space for mechanical features**, such as mounting holes, connectors, and heat sinks, where traces or components shouldn't go. 2. **Protecting sensitive areas**, like RF zones, from routing that could affect signal integrity. 3. **Enforcing design intent**, such as keeping parts out of high-heat zones or away from noisy power areas. ### How to specify Uploading a keepout to Quilter for layout candidate generation is easy. Just define it in your CAD tool as you normally would and save it along with your other design files when setting up a new layout job. # Net Widths by Layer Explanation of Quilter’s Net Width constraint, detailing careful usage guidelines, potential conflicts with automatic constraints, and instructions for specifying custom widths. ### Net Widths by Layer In general, Quilter's development philosophy is to understand your design at the [Physics Constraints](/physics-constraints/overview) level so that design parameters, such as Net Widths, can be independently managed on a constraint-by-constraint basis by Quilter, as opposed to using traditional design rules that can be overly conservative and cumbersome to define. That said, Quilter supports a "Net Widths" constraint that can be used to specify specific trace widths for individual nets and net classes within your design. If you want to assert custom [Fabricator constraints](/using-quilter/fabricator-constraints) for your design, we recommend waiting until our support for custom stack-ups and design rules is complete. {% hint style="warning" %} **Use Net Widths Carefully**\ We don't recommend using the "Net Widths" constraint for global enforcement of fabrication rules. Net widths can "collide" with other physics constraints that automatically manage net widths and spacing, including [Power Nets](/physics-constraints/power-nets). We recommend using this constraint sparingly. {% endhint %} ### How to specify To specify a preserved pour, add the specific net or net class to the "Net Widths" constraint during Circuit Comprehension by clicking the `Add`, `Add multiple`, or `Add by netclass` buttons beneath the table.
Add by net
Add by net class
| Topic | Description |
|---|---|
| /pages/sewZKbPlw2MBH1jmjKWj | Job details provide an overview of the key information for the layout job request and its generated results. |
| /pages/KlfAFXD8YVuW9Uc6E3KD | Candidate details capture essential information about the candidate that can be utilized to sort and filter your solution space. |
| Topic | Description |
|---|---|
| /pages/64CusstmdLbAVTzL0oiU | Quilter's /pages/CWMdylEJnQkGi7wLROTd help you understand the physics constraints we were able and unable to meet. |
| Topic | Description |
|---|---|
| /pages/E5SgLPBfGIvdVSpCkdOv | Continue candidate review offline by downloading your preferred candidates in their original file formats. |
| /pages/QWL3m6I70joJgcispRXS | Utilize Quilter's iterative capabilities to refine your design further across multiple layout jobs. |
Job details summarized after file upload when configuring a new layout job.
| Field | Description |
|---|---|
| Job name | The name you assign to your layout job. If you wish, Quilter will automatically generate a default name from your input files. |
| Board dimensions | The dimensions of your board, in centimeters. |
| Components | The number of components detected within your design. |
| Components to place | The number of unplaced components that Quilter will attempt to place within your design. |
| Pins | The number of component pins detected within your design. |
| Pins to route | The number of unrouted component pins that Quilter will attempt to route within your design. All layout jobs submitted to Quilter must have > 0 pins to route. |
| Pin density | A metric that identifies the % routable surface area of the board, specified as: Pin density (%) = (Component Pin Area) / (Total Board Surface Area) * 100% |
| Field | Description |
|---|---|
| Candidate name | Idenfities the candidate number for easy identification |
| Routing completion | Identifies the % of pins to route that were successfully completed within the design. |
| DRC error count | Identifies the number of Quilter-generated DRC violations. Quilter currently prevents any candidate with DRC errors from being surfaced to Candidate Review. |
| Single-sided | Identifies whether the candidate uses single- or double-sided placement. |
| Layer count | Identifies the number of layers used in the design. |
| Minimum trace width | Identifies the minimum trace width used in the design. This figure identifies the actual minimum trace width in the design (not the fabrication rules), which may include narrower widths resulting from neck-downs. |
| Minimum trace clearance | Identifies the minimum trace clearance used in the design. |
| Minimum via diameter | Identifies the minimum via diameter used in the design. |
| Minimum drill diameter | Identifies the minimum drill diameter used in the design. |
| Via count | Identifies the number of individual vias used in the design. |
| Filter | Type | Behavior |
|---|---|---|
| Show 100% routed candidates only | Toggle | Activating this filter hides incomplete (<100% routed) candidates |
| Single-sided | Checkbox | Activating this filter shows only single-sided layout candidates |
| Trace Width (min) | Single select | This filter shows candidates with minimum trace widths that match or exceed the specified value |
| Trace Clearance (min) | Single select | This filter shows candidates with minimum trace clearance that match or exceed the specified value |
| Layers | Multi-select | This filter shows candidates whose layer count match the specified selection(s) |
| Fabricators | Multi-select | This filter shows candidates whose stack-up is designed for fabrication by the specified manufacturer(s) |
| Control | Description |
|---|---|
| 2D mode | The default viewing style displays your design in a locked birds-eye view without three-dimensional features. |
| 3D mode | Displays a 3D perspective of your board with a materials-based visual theme. Enables free rotation. |
| Flip icon | Quickly flip your board from front to back |
| Quick find | Locate and switch to a specific camera angle for a particular component or pin within your design. |
1. **Control object visibility by layer**\ The first set of controls lets you toggle the visibility of all objects on a specific layer or expand the nested tree structure to toggle the visibility of individual objects on that layer. These toggles are always available, even if there are no objects on that layer – for example, if there are no pours on `LAYER_1`. \ Layer-level toggles are helpful for inspecting individual layers of your PCB at a time.
2. **Control global object visibility**\ The second set of controls lets you toggle the global visibility of specific object classes across all layers. These toggles are always available, even if there are no instances of that object in your design – for example, if there are no placement regions defined for your layout job.\ \ Global-level toggles are useful for inspecting trace paths that span multiple layers of your board. # Reviewing PRCs Overview of Quilter’s PRC reports, detailing how to interpret results grouped by constraint types, view passing and failing checks, and understand individual physics rule evaluations. ### Overview Every layout job comes with a [PRC report](/physics-rule-checks-prcs/overview) that summarizes the results of physics unit tests Quilter runs for each of the defined layouts in your job. The goal of PRCs is to help assess whether the layout candidate generated by Quilter is likely to perform as expected. ### Interpreting PRC results #### How PRCs are organized Quilter's PRC reports are generated for every candidate Quilter considers. The PRC results are organized by the parent constraint type they support – for example, bypass capacitors, differential pairs, and so on. You can expand or collapse the individual results for each constraint group by clicking the header for that constraint type. A summary of the aggregated PRC results is also available on the right side of the constraint group header. You can filter the PRC checks shown to view all of them (the default) or only the ones that failed to pass. #### Reading individual results
Access job actions from the layout jobs home page.
Access job actions from the candidate details header.
| Job Action | Description |
|---|---|
| Details | View details about the input files, physics constraints, and design parameters associated to your layout job |
| Rename | Update the name of your layout job |
| Delete | Delete this layout job from your Quilter account. Deleted layout jobs cannot be recovered. |
| Duplicate | Copies the input files and physics constraints defined for your existing layout job to a new draft job. |
Click the button to download your layout candidate