I love that this document gives a very complete overview of all the steps that go into creating a printed circuit board! I always say, KiCad is easily better than any ECAD tool you can buy for $1,000 or less. They also have a better built-in library than I've ever encountered in a paid tool, which is worth a lot if someone just wants to crank out a quick project.
Kicad is good enough for 95% of all circuit designs. Maybe 99% in version 7 - haven’t really pulled the bandaid off yet in that regard.
If you’re working in a big team, or making really complex stuff like telecom equipment or server motherboards, then I can see the appeal of shelling out for PADS or Altium with their library management and package automation tools.
But, I’ve designed hardware on a consulting basis before using Kicad as my EE CAD package of choice. It was more than enough for my needs. That includes simple two layer boards all the way to pretty complicated six layer embedded Linux systems.
I particularly like that it comes with an embedded 3D viewer. Coming from only ever using ORCAD before that, it was a huge breath of fresh air, and significantly cut down on the number of connector mistakes I’ve made since.
KiCad has been significantly improving its library management lately. With 6.0 it got a Plugin and Content Manager, allowing you to trivially add external content libraries to it. The 7.0 release added support for ODBC-based Database Libraries, allowing you to hook it up to basically any database you want in order to provide part metadata.
Personally, I thought 5.0 was a big pain to use. With 6.0 it actually got kinda decent, but I still had to write custom code to work around a few of its warts. However, 7.0 shows that it is rapidly moving towards being a serious threat to the proprietary market leaders, and I can't wait to see what the future will bring!
The 7.0.x point releases have also consistently addressed a lot of little quality of life pain points and bugs.
It's really all so enjoyable to observe from the armchair. I'm not embedded into the Kicad community/project, but it certainly feels like the momentum is there.
I love these tentpole moments/projects in the overall fabric of the industry, when an open source project reaches "momentum escape velocity" after sticking around long enough to snowball and eventually eclipse the proprietary alternatives in terms of sheer scale. For example, it's very hard to outcompete the Linux kernel for general applications now simply because everyone's working on it, and no single company can build and retain a team that can outcompete an entire ecosystem, outside of picking very particular battles (e.g. QNX<>Linux).
Cynics will point out that this often describes an area of software simply commodity-fying enough that FOSS can now catch and keep up, and pragmatists will point out that the commercial packages often still retain a key feature for e.g. a leading edge/high-end application you can't get from anything else. But be that as it may, it's still beautiful.
I like to identify and start watching the projects that may be on the verge of becoming this in their particular domain. For example, Blender may get there or is already there. Could Krita? 20 years from now, could this be Bevy for the game engine space? There's usually certain markers, e.g. healthy governance (this is what gives the project the legs to make it long enough), good mission statement, hygienic tech stack, that sort of thing.
For young programmers, this is the type of project to find and join. You end up running an industry when you grow up, and, if that's important to you (there can be other priorities, e.g. shipping important products in general), your hard labor won't die and disappear one day with a company.
> KiCad is easily better than any ECAD tool you can buy for $1,000 or less.
Well, we pulled the plug on Altium when KiCad 6.0 was released and have not looked back. We got really sick of Altium nonsense, just had enough of it. Their focus on cloud to sell the company really caused damage and every release broke something new.
We do everything from relatively simple four layer boards to complex multi-GHz boards with challenging signal and power integrity constraints. KiCad has no problem at all providing the tools we need to complete these designs. I can't see ever going back to Altium.
As far as libraries are concerned. Professional organizations rarely (I would say, never) use built-in libraries. The reason for this is that you are responsible for reliability, manufacturability and product life-cycle. This means every component needs to be qualified and fully vetted to the extent required by the nature of the product. Which, in turn, means that you are always going to want to define all the components and use internally-built libraries you can trust. There are other reasons for this, that's just the basics.
That's not really a limitation for professionals, though.
Built-in component libraries are always going to be incomplete, and literally all of them kinda suck. Professional PCB designers almost always have to either create their own footprints from the datasheet, or get them from someone else who did. Trusting third-party footprints is probably the easiest way to end up with fundamentally broken prototypes which are nothing more than fancy desk decorations - I can unfortunately speak from experience.
The built-in libraries are basically only used for trivial things like resistor footprints, 2.54mm headers, or solder jumpers. KiCad's libraries are more than good enough for that.
Footprints are less of an issue than schematic library. If you need to say tailor-make QFP-48 footprint that might be some work but you will likely reuse it for multiple parts.
Until you find out that a manufacturer decided to use a footprint which looks standard, but uses a custom pin numbering. The schematic symbols are right and so are the KiCad-provided footprints, but they are still not going to work together.
But yeah, a lot of chip footprints are quite standard, or require only small modifications from those standard footprints. I do still have to hand-draw quite a few of them, but that's because my designs are usually quite heavy on relatively obscure peripherals.
While I agree with crote's reply that this isn't a limitation at all for a professional, I'm surprised to hear your opinion. Of all the libraries that come with tools, I find KiCad's to be the highest quality with regard to footprints (in addition to having a ton of them available). Perhaps the symbol libraries are more limited, but that being said, I've never found a mistake in KiCad's library. I've definitely found mistakes in the built-in Altium libs. To be fair, Altium started getting much better after their acquisition of Octopart, and it started to be easier to find things through the built-in search.
As a professional that lays outs boards about twice a year…
I have never understood the concern about the built in library. Professionals barely use it. You MIGHT use it for some SMDs, but that’s about it. Everything else you are going to get or make or download the specific footprint.
I agree with the parent comments. You will spend an absurd amount of time making library components, and you can't trust 3rd party. The 3rd party sites are a great starting point to take out some of the grunt work, but you need to tweak them.
Your (cad tool) component library is your most valuable resource, and in my opinion more valuable than schematics/layouts. You have your own proven set of components that you know will work in manufacturing. Even the standard passive SMD footprints need to be tweaked for your specific requirements (ISO, design for manufacturing etc).
In regards to Kicad... great tool for 90% of designs. I would say as a rule of thumb, if your design can be manufactured at one of those online, cheap PCB manufacturers (for say, $10-$20) then Kicad will cover it. Once that calculator tool starts going higher you're probably doing someone more complicated that warrants the more expensive tools.
It's not a limitation at all. There are no PCB design programs that have every part ever manufactured in the library. At some point you're going to have to make a PCB footprint yourself no matter what software you use. Pretty much all datasheets have explicit measurements of the footprint layout. Even better if you have the physical part and some calipers.
Has there ever been an attempt at a good standardized machine-readable exchange format for datasheets in general, btw? Feels to me like it still all comes down to authoring tools for making pretty PDFs, and while there's something to be said for the universality of a good ol' paper-style doc made for human eyeballs, but it's also silly (not to mention error-prone) for Engineer A to use a SW package to make a schematic for a datasheet PDF, and Engineer B then reading it and inputting it back into a SW package.
I assume many vendors also offer parts libs/files in EDA formats, but are those proprietary or is there any de-facto standard like Gerber files?
It'd also be nice to browse datasheets' other contents in a consistent interface right in the EDA or in a web app instead of dealing with a zoo of PDFs in vendor-specific styles.
Maybe it's this kind of thing we'll automate using LLMs/models ... give it a description of the scripting API of the EDA, give it the PDF, make it map a footprint from one to the other. Or to a standard format. For back catalogs that could be useful ...
>I assume many vendors also offer parts libs/files in EDA formats, but are those proprietary or is there any de-facto standard like Gerber files?
It would be great if part manufacturers would just make the footprint files and 3D files available for the parts, because I have no doubt that in 99% of cases the manufacturer has those files somewhere. I've tried to social engineer this out of some companies with very little success. I don't care what format they come in, I'll get it sorted out. I have collected an arsenal of file format conversion tools.
>Maybe it's this kind of thing we'll automate using LLMs/models
I have no doubt that at some point in the future you'll just give the AI the PDF and it will spit out a PCB footprint in any file format you want. We're not close to that though.
Making symbols and the occasional footprint is a fact of life, I'm afraid. Sometimes you can download them from the vendor, or in a pinch, SnapEDA, but chances are you'll want to modify them anyway.
I've personally enjoyed using DipTrace, very intuitive and easy to pick up, it's far less than $1000. I've been hearing good things about Flux but haven't tried it myself yet. I hear it's not complete, but coming along quick.
Comments like that are hard to respond to. The topic here is KiCAD, but you haven’t addressed whether you have given KiCAD 7 (or 6) a real try. Without that information, and without understanding what you didn't like about KiCAD, it’s hard to address these other options, and you don’t really even mention what you actually like about DipTrace. “Intuitive” and “easy to pickup” are arguably properties of KiCAD, for anyone familiar with schematic capture and PCB design. It used to be harder, but tons of effort has been poured into KiCAD for many years now.
Why would anyone want to use an old, proprietary program like DipTrace when KiCAD is free, cross-platform, open source, and arguably just plain better? DipTrace has a Mac version, but all of the discussions I see online indicate that it still hasn’t been updated to work properly on Apple Silicon.
It’s been probably 7 or 8 years since I last saw someone using DipTrace, and I wasn’t impressed then. It’s also $995 for the full version (the closest to KiCAD’s feature set), which is hardly “far less” than $1000, but the absolute minimum version I would even consider would be $400. I’m amazed at how their website seems to be exactly as I remember it from so long ago.
Looking through their marketing site, I literally don’t see a single thing that is better than KiCAD. I personally just don’t understand why anyone would buy DipTrace in 2023. So, it’s hard to respond without just coming off as dismissive. I wish I could provide a more balanced comment that makes it seem like DipTrace is still competitive, well-maintained software… but that isn’t what I believe. I’m sure it’s fine for basic use cases, but KiCAD is great for those use cases and so much more.
Flux seems gimmicky at first, but browsing through their materials, I am at least impressed at the effort they seem to be putting in. They even had a comparison page against KiCAD, but this attempt to sell against KiCAD ended up being some disappointing nebulous statements that didn’t seem to have much merit, apart from the real time collaborative nature of their product, which seems to be their one actual advantage.
Different people can have different opinions, of course, but KiCAD is great quality software with a lot of momentum.
If you want to share what features you like most about DipTrace, or what you think it does better than KiCAD, that would certainly be interesting to hear.
Using Diptrace I've appreciated the reasonable pricing $150 for thr lite version), the online library integrations have been working well for me both in ease of finding what I need and dropping it right in, but also in the quality of the footprints, etc.
I also prefer thr UI interface. Many ecad solutions are clunky and old school to use in their UI. In Diptrace the whole thing is basically achieved by left and right clicking, selecting from context menus.
There aren't too many ECAD/PCB tools I haven't at least played with a bit... Diptrace has some neat features but overall I can't quite get used to their design flow and library process. I know Stephen Kraig from the MacroFab podcast extols its virtues often, which is why I tried it out in the first place.
As for Flux.ai, that one is new and I've been out of the pure PCB world for a little bit so have not messed around with it. To be honest, I'm not a fan of browser-based tools, personally. Even Altium 365's new features (though some are certainly useful), take some getting used to - I suppose I don't really like the "data in the cloud" prospect that much. That being said, I did link Flux.ai first on my recent survey of AI/ML-based PCB tools [1] as they seem to be quite far along.
The problem is that PCB design tools all lie on a spectrum from "jump in and design the board right away" to "you'd better spend a while getting your libraries and environment ready to go". Tools like PADS seem to be more towards the latter, while Altium and KiCad are closer to the former. OrCAD is probably around the middle or so. It can be tough to give a tool a fair assessment if it takes more effort to get going on a design.
I think KiCad is suitable for beginners, even if you haven't breadboarded yet, but note that Breadboards exist to give you lots and lots of practice before you start spending money on PCBs.
Each PCB is a bit of money after all, and if you are inevitably going to make a mistake it's better to breadboard.
But as far as difficulty goes, things like KiCad exist for a reason. Computer automation and checks help, as well as parts libraries for you to download/copy rather than building your own footprints.
So feel free to start KiCad + ordering boards the moment you are willing to lose money on your mistakes!!! It's not any harder IMO. Just costlier.
----------
As far as learning Kiad, this guide is good but it's missing the broad overview IMO. So here's my broad overview:
1. Build symbols representing each chip or part you plan to use. Standard parts (like resistors) already exist in KiCAD7.0 library, but inevitably there will be a few missing parts for your project. This may be called symbol editing, but perhaps it's more accurate to call it pin-naming.
2. Hook up the parts together in the schematic editor. Double check symbols and their pinouts now. Fix symbol mistakes now. This creates a computerized set of nets (connections) that KiCad will try to enforce moving forward.
3. Choose the footprints for every part in your schematic. Beginners should probably use 0805 (inches) parts or larger. (equivalent to 2012 metric). Like #1, there is a footprint library for common parts, but you will inevitably have to create at least one or two footprints of your own for your personal projects. Footprints tell KiCad where pins are located physically (inches or mm) here vs there.
4. PCB layout begins. KiCad has a 'rats nest' based on your schematic. As long as #1, #2, and #3 are correct (ie: correct symbols / pinouts, correct schematic, and finally correct footprints) you probably can't make a mistake anymore. Assuming a low speed beginner circuit anyway (the professional would focus on physical issues like heat, noise, EMI, crosstalk and other such issues. Beginners can likely ignore all of that assuming you chose a suitable beginner project).
By step#4, KiCAD knows the name of every pin (#1), which pins should be connected to which pins (#2), and where each pin is located physically (#3). All that's left to do is draw your wires together in step#4.
I would even recommend decoupling the processes a bit. That is - start with a known good schematic, ideally one that exists as KiCad schematic already (look for KiCad projects on Github). Practice creating a board outline, placing some parts and routing traces, make yourself familiar with the tools around that (how to deal with layers; how to use the design ruler checker; the 3D preview to find blatant mistakes with connectors or so; how to export the files (if necessary - Aisler accepts KiCad files for example)). If you want, export it and order it. At JLCPCB that should be $2/2€ + shipping if five pieces and HASL is good enough. Then maybe enter a known good schematic oneself. Then create a simple circuit on breadboard, turn it into a schematic, enter that. ...
I'm brand new to this. I've got a relatively simple schematic from the 1950s I want to reimplement, to have a functioning thing on my desk.
As you say, a few parts are missing (particular vacuum tubes). Unfortunately, every time I start implementing stuff in kicad, that's where I get overwhelmed... And to someone who's not a hardware guy, I'm completely stymied. Can you suggest what I should do?
A couple people had some great comments that should get you started; I'd just like to add that you don't need to do everything at once either and your workflow can be flexible. When I'm making a board with weird parts, I like to first just go into the symbol editor, make a new project library, and draw out whatever I need for my project with the correct pin assignments. Then at least you can focus on copying the schematic over and getting the ball rolling.
Once you are happy with the schematic, and parts are roughly placed where you want them on the board, you can go ahead and jump into the footprint editor, make a project library in there with the same name, and draw the physical copper layout for your tubes or whatever else to attach to based on datasheets or caliper measurements. Then you run footprint assignment to match up all the symbols with their corresponding footprint, and update the PCB to populate it with parts to lay out. Once the parts are placed logically where routing will be sane, follow the ratsnest connection lines to get your board routed.
Last you want to go to your manufacturer's website, look up all their specifications on board construction [0], and make sure all their recommended design rules and board stackup are plugged into board setup. This may mean going back and changing some trace sizes, trace placements, vias, and so on to pass design checks. Later you will do this earlier, but it's better not to get bogged down at first and just start designing, and you'll learn why things are routed as they are.
After this, spend time inspecting your board, looking for errors, making sure all checks pass and everything makes sense after a few reviews. Then export your gerbers and drill maps and send the zip to your manufacturer.
It's a little daunting at first because there are just a lot of steps between a schematic -- essentially a cartoon version of what your circuit will be, and a layout -- what your circuit will actually look like. You don't have to do every step at once and once you have the schematic drawn, you can just keep adding to it until you have something that works.
Each of the steps I outlined above, #1, #2, #3 and #4, are a new set of keyboard buttons and GUIs to learn for KiCad.
Yes, it's a lot to take at once. But fortunately, you only have to move forward one step at a time.
--------
Maybe starting at #2, Schematic, would be the only 'out of order' thing I'd recommend. There might be enough library parts to fill out a large section of your schematic (or maybe not...).
Inevitably, you will have to tackle #1 (symbol editor) and #3 (footprint editor) before you finish #2 and start step #4.
---------
I agree it's a lot to take in at once. But after you do all four steps and understand them, there is a sense of order and process. Especially as #1 (setting the pinout on a symbol), #2 (saying what pins are connected) and #3 (saying which pins belong where physically) are all accomplishing computerized checks to make #4 less error prone.
It's a lot of info to tell KiCad, and any other PCB editor will need all this information as well, so none of it was wasted effort.
It's just a lot of up front complexity that really is intimidating.
---------
#2 schematic editor might be a good starting point because it's what you expect to do. #1 and #3 are somewhat unintuitive steps.
In addition to the other recommendations in the thread, it may be useful to learn how the whole process works (KiCad, ordering or making PCBs, and assembling everything) with an even simpler circuit with just a few components. Making a simple battery + LED + resistor + switch circuit would involve learning almost the same amount about KiCad etc. as a more complicated circuit (within reason), with a lot less opportunity to be overwhelmed by component selection, PCB layout, etc. It would also be fairly cheap to make mistakes, since the PCB could be quite small and would probably cost only a few dollars even from a fairly high-end PCB manufacturer (I like OSH Park, but they can be expensive for large boards; see pcbshopper.com for price comparison).
I think you can just use CONN_01X00 pin header parts to represent tubes on the circuit schematics, then define just the footprint for the tube, either from its datasheet or ANSI/ISO/DIN/GOST connector specification. Then that footprint can be assigned to corresponding J0 on the imported PCB file. You can also print the PCB to visually test fitment. That might not be the correctest way but nor should be the wrongest approach.
One of the most confusing things when I started using KiCad is its two main features, EESchema and PCBnew, are basically two independent open source projects. So they're not tightly coupled, but works by importing and exporting files and manually assigning items in one side to the other.
For me it helps a lot to get some one-on-one to get me rolling.
Consider findig a makerspace nearby and see if they have some courses or people willing to help. There's one in my town and they have an active slack and weekly "maker evenings" where it's easy to get help.
Alternatively find some online communities where you can get some help.
As an example, this[1] YouTube channel has some great videos on layout and more with KiCad, as well as a very nice Discord community with newbies and professionals. I'm sure there are others, but that's where I got some great help when I got my feet wet.
Can you share the schematic? I'm not familiar with KiCad or other similar software, so take this with a grain of salt, anyway I think that for simple schematics, especially that old, meaning all tht parts, single side pcbs, unless one is recreating a complex circuit, probably the "by hand" approach is a lot faster than using software.
Or read a section first (e.g. how to create a footprint or symbol) to better understand what is happening and then watch a tutorial video of someone doing exactly that to see it in action.
I'm not sure why you position things as if it's either KiCAD or breadboards. Whenever I've designed a PCB, I've gone from breadboard, to schematic, to PCB (the last two in KiCAD). The breadboard is a necessary first step to make sure that the circuit works in the real world, not just in theory.
These days, with $5/sq-inch 2 layer boards and cheap prices for 4 or 6 layer boards... This makes 40+ pin microcontrollers and 200+ pin BGAs even are well within the means of a modern Hobbyist today in 2023. But there is no hope for these chips to ever be adequately placed on a breadboard.
-------
From my experience, breadboards and protoboards are for simpler learning projects. But you rather quickly grow beyond what a breadboard can offer.
Breadboard when you are at breadboarding level. But once you graduate to greater levels of complexity, you can only buy custom pcbs (and possibly 4 or even 6 layers at that). It's literally impossible to breakout a full square ~17x17 pin BGA on 4 layers, let alone dealing with EMI or signal integrity effects.
That's true, I guess my designs are rather more basic than that. I never managed to figure out how to work with these slightly more complicated chips, though I'd like to.
Start with a 32-pin beginner uC like STM32G0, AVR64DD32 (more modern version of AtMega328pb), PIC, or other such chip.
Find a useful sensor to some itch you have: temperature, pressure, weight, time, CO2, accelerometer, whatever is interesting to you. Make a design that reads the sensor and writes it to LEDs (red is bad, green is good), or 7-seg displays, screens or some other visual device.
Order 3 or 4 boards, low temperature lead free solder paste, no clean flux (bullshit, you should clean it off), solder wick, cheap isopropyl alcohol to clean the flux after the fact, a pancake grill, and 3 or 4 copies of all the chips you need.
If you stick with larger surface mount chips like 0805 inches or 2012 (metric), a soldering iron is sufficient for rework. Smaller chips require a hot air gun.
Try to stick with larger chips like SSOP or even SOIC chips. TQFP should be doable with the sloppy then flux+solder wick cleanup method but don't go any smaller as a beginner. SOT-23 is easy.
--------
Mess up your first attempt. That's fine, you have 2x more tries.
Build it successfully using pancake griddle reflow method (solder paste on the pads, be sloppy if you must. Place enough so all the components stick to the gel-like solder paste in place. Heat to 350F or 138C for low-temp solder paste (you can tell because it liquefies and all the components start floating).
Use a toothpick to push items back into place, turn off heat. When cool, use lots of flux, solder wick + solder iron to fix bridges (should be super easy. If it's not easy, use more flux and try again and/or buy new solder flux+wick. That stuff goes bad every 2 months).
Done. Except you probably made a mistake on your schematic. Fix that, order new parts, try again and be happy the time it finally works.
Keep your flux, wick, and solder paste refreshed (throw out old consumables, buy new every few months) and you should be good to go.
Order a x10 jewelers loupe or x15 or x25 to visually inspect these solder joints. If all looks well, grab your fire extinguisher and turn on your electronics project! Best of luck.
Thanks for this! I've already soldered and designed a lot, I just don't know how to find the microcontrollers' "boilerplate" (eg all the pull-ups and pull-downs it needs to boot, capacitors, stuff like that). It also doesn't help that my C isn't great, but I guess I can write Rust on the STM32 nowadays.
This is about a YouTube video that walks through a reference design for an STM32F1, a beginner friendly chip with very simple startup.
You only need the 100nF capacitors as indicated in the reference documents, but the video also adds a Ferrite Bead + Pi filter (1uF + Ferrite + 1uF), which is considered a good practice to reduce noise... but likely is optional and not needed at a beginner level.
I moved from KiCad to Altium: Altium is 100x slower, but I am substantially more productive.
KiCad desperately needs a stackup-aware constraints system, differential impedance/trace width computation, multi-trace routing, etc. in the same way that Altium has. I wish I had time to add the features I want: KiCad is so much more pleasurable to use on average.
A decade or two ago, I would have recommended The Art of Electronics by Horowitz and Hill. I learned from that textbook, plus a lot of home experimentation, and application notes from the IC manufacturers notably National Semiconductor. Those app notes are still available online from Texas Instruments, and still relevant.
Today, I help colleagues get started in electronics. They often have some sort of science or non-EE engineering background. I recommend diving into the Arduino universe, perhaps by looking through the many tutorials at the Adafruit webiste. (And buying her stuff).
Learn, the way a lot of us old-timers learned to code: Take some working program, duplicate it, and make minor changes, and see what happens.
Even if your ultimate interest is analog rather than digital, the tools that you learn to make in the digital realm, such as measurement, will help you test your beginning analog circuits. On the other hand, if you're interested in analog, you may have a reason, such as audio or music electronics, in which case, there are a lot of documented projects out there to build and learn from.
Don't work with anything potentially dangerous at first, if ever. Things that can release a large amount of energy (voltage, current, mechanical, heat) if your code has a bug are worth leaving to the real engineers.
This is solid advice. Find something you're interested in and go from there. If you can't find anything, maybe build something like a weather station. You'll start with a simple task: read the ambient temperature and display it somewhere (on an LCD, in a react app on the cloud etc). You'll then need to start solving problems, like how do you read outside temperature where you'll learn about batteries, wireless technology, water proofing etc.
Don't stress about the electronics and certainly don't be intimidated by text books. When you're starting out you don't need to really know the theory of transistors, but maybe a few youtube videos on the basics won't go astray. Think about if you were learning to code... would you read a book and start stressing about computer architecture? Some people might, but most won't. They'll hit up create-react-app and mess around with that.
When you're learning it's important to get instant feedback. Just learn how to blink an LED and you've completed the hello-world of electronics.
If you can code, you can do electronics. Same for the reverse. The skill sets are closely aligned.
But my KiCad files are on a harddrive that is not my "/" drive, and Snap doesn't allow KiCad to read those files. I tried with a bind mount, but then the symlinks in my project files don't work ...
Now I'm thinking of compiling everything myself, but it seems a daunting task.
If you mean that KiCad needs dark mode, this can be done using a combination of GTK (or QT?) color themes, which are associated with your system configuration, not KiCad, and color themes for the editing tools, which can be changed in the preferences menu. I found some reasonable options here [1], but if you're picky (like I am), you can write (or generate) your own. In the current version of KiCad, you can choose between themes (files in the appropriate directory) with a drop-down menu in the KiCad preferences, rather than editing the default configuration.
