1. Pick the tools
A few words first. A schematic is the circuit diagram, and a netlist is the list of what connects to what. The layout is the physical board: where the parts sit and how copper traces join them. Drawing those traces is called routing. A footprint is the pattern of copper pads that one part solders onto. Gerbers are the files a board maker (a "fab") builds from, one per layer. A BOM is the parts list. Headless means run from the command line, with no window open.
| Tool | Licence | What it does from the command line | How mature |
|---|---|---|---|
KiCad (kicad-cli) | GPL-3.0 [1] | Runs the schematic check (ERC) and board check (DRC), and exports Gerbers, drill files, component positions, a bill of materials (BOM), SVG, PDF and a 3D render. Its command list has no routing or auto-placement command [3]. | Active. Version 10.0.8 was released within the last 60 days, with patch releases every 1 to 2 months through 2026 [2]. |
| SKiDL (Python) | MIT [5] | Describe the circuit as Python. Writes netlists, a BOM and KiCad schematics, and has an electrical rules check. Its generate_pcb() step needs KiCad installed [4]. Layout is left to the layout tool. | Version 3.0.0 uploaded within the last 60 days; supports KiCad 5 to 10 [6]. |
atopile (ato) | MIT [7] | A small description language. ato build solves the design, picks parts and updates a KiCad layout file. Placing and routing is still done in KiCad. | Pre-release. Its docs say it is under heavy development and you may hit rough edges. Its latest stable-tagged GitHub release is v0.12.5 (released earlier this year); newer tags are pre-releases. The package on PyPI needs Python 3.14 [8][9]. |
| tscircuit (TypeScript) | MIT [10] | Describe the board in TypeScript, preview it in a browser, export Gerbers, pick-and-place and BOM files, and export to KiCad with tsci export [11]. You set part positions by hand; the team says auto-layout and an autorouter are still being built. We could not confirm it runs fully headless on a server. | Very active, but its version number (0.0.3192) points to continuous releases rather than a stable 1.0. |
| Freerouting (autorouter) | GPL-3.0 [12] | Reads a Specctra DSN file and saves a routed session file, e.g. java -jar freerouting.jar -de MyBoard.dsn -do MyBoard.ses. Needs a Java runtime. The router is single-threaded [13]. KiCad can use it through a plugin in the PCB editor. | Release v2.5.0 within the last 60 days. The maintainer says he spends about 4 hours a week on it, and the API is beta. Routed boards still need your review. |
| ngspice | BSD-3-Clause [14] | Circuit simulation in batch mode, e.g. ngspice -b -o result.log circuit.cir [15]. KiCad uses it as its simulation engine. It simulates only the circuit and part models you give it; it does not check layout, footprints, heat or whether a model matches the real part. | Version 47, released within the last 6 months (per Wikipedia). |
Our suggestion: start with KiCad alone. Draw a very small board, run the checks from the command line, and export the files. Add SKiDL, Freerouting or ngspice later if you want them. atopile and tscircuit are interesting, but they are newer or unfinished, and we have not tested them.
Install notes. These matter mostly to whoever does the installing, which is usually your assistant. Ubuntu 24.04's own package list carries KiCad 7.0.11 [19], much older than the 10.x documentation. The KiCad team publishes a package archive for 10.0 that has Ubuntu 24.04 builds [20]. KiCad also publishes Docker images meant for kicad-cli; it says using the graphical interface through Docker is not supported [21]. KiCad's older Python scripting interface (pcbnew) is deprecated, and its replacement is meant to control a running copy of KiCad [17][18]. So checks and exports with kicad-cli are the solid part of an automated flow; scripted board edits are the least certain part. Use the pcb export gerbers command; the older singular export gerber was deprecated in KiCad 9 [16].
2. Do you need a pod?
A pod is RunPod's name for a computer you rent. A CPU pod has no GPU; a GPU pod has one.
- No pod needed if you have a laptop or desktop that can install KiCad. The tools are free and run on a normal computer.
- A CPU pod can help if you only have an iPad or a weak laptop. RunPod documents CPU pods as priced by vCPU, with the same networking and lifecycle as a GPU pod, but with only container disk and network volume storage (no persistent volume disk) [22]. We do not quote a CPU pod price, because we could not confirm the unit. The RunPod console shows the exact price per hour before you deploy [25].
- A GPU pod adds nothing for this work. For comparison only: an hour on an RTX 3090 (24 GB) is $0.50 on Secure Cloud or $0.22 on Community Cloud, rates checked within the last 30 days [24]. Do not pay that for a circuit board.
Pods are billed per second [23]. We have not run this guide's steps on a pod ourselves yet (see section 8).
3. What AI can and cannot do
Can usually do: install tools, write and run kicad-cli commands, read ERC and DRC reports, fix reported errors, regenerate outputs, write SKiDL, atopile or tscircuit code from a plain description, draft a parts list and a checklist, and explain a DRC message in plain words.
Cannot be trusted to: know that a footprint matches the real part, or that a symbol's pin numbers match the datasheet; judge power design, analog behaviour, heat, radio noise or antennas; see fine detail in a board image; know today's price, stock or fab quote (it must not invent them); or know your enclosure and how you will assemble the board.
The evidence. EDA Bench (ICML 2026 listing) tested AI agents on 35 tasks taken from open-hardware projects. The strongest setup scored 4.58% on the functional checks. It produced complete KiCad projects for 21 of the 35 tasks but failed most of the functional checks. The authors conclude that "parseable or plausible PCB artifacts are not necessarily electrically functional artifacts." [26] A separate study, PCEval, found language models do much worse on physical breadboard layout than on logical circuits, with pin conflicts the most frequent physical error. That is breadboards and Arduino rather than PCBs, so it is only indirect evidence [27]. Models change quickly, and these numbers will not transfer exactly to the assistant you use.
What a clean ERC/DRC does and does not mean. KiCad describes ERC as detecting incorrect and missing connections [29] and DRC as detecting design-rule violations such as clearance and minimum width [30]. A clean report means the connections and spacing match the rules you set. It does not prove the board works. You can also set individual checks to "Ignore" in the project, so "0 errors" can hide things.
A human must check, before any order:
- Every part's symbol pins against its datasheet.
- Every footprint against the datasheet's land pattern. Print the board at 1:1 on paper and lay the real parts on it.
- Polarity and pin 1 for diodes, LEDs, electrolytic capacitors, ICs and connectors.
- Power: current per trace, regulator limits and any battery connection.
- The ERC and DRC results, read by you, including which checks were ignored.
- The Gerber files, opened in a separate Gerber viewer. JLCPCB itself recommends cross-checking with a third-party viewer: outline continuous, holes aligned, silkscreen as expected [28].
- The fab's own preview and quote, and the assembly files if you order assembly.
- Mechanical fit: board size, mounting holes and connector positions.
4. From zero to a first board
- Pick a very small first board, such as an LED with a resistor and a 2-pin header. No mains voltage, no batteries.
- Decide where to work: your own computer (install KiCad 10) or a CPU pod (section 5). Do not start a pod unless you need one.
- Describe the board in plain English and have your AI assistant list every part with its datasheet pinout and footprint before it draws anything.
- Have it generate the schematic and board, then run ERC and DRC from the command line. Fix, rerun.
- Export images (SVG or PNG) and look at the board yourself.
- Optional: autoroute with Freerouting, then rerun DRC and review the routing.
- Review by hand using the list in section 3: pins against datasheets, footprints printed 1:1, polarity, power, outline.
- Export Gerbers, drill file, position file and BOM. Zip them and download them to your own device.
- Open the Gerbers in a separate viewer. Get a quote on your chosen fab's own website, and check the fab's preview.
- Order only after you have reviewed everything. For a first board, order the smallest quantity.
- If you used a pod: download your files first, then terminate the pod, and check the pod list shows nothing running.
5. If you use a pod: what to set up
- Account: you create the account, add a small balance and turn on two-factor authentication yourself [25]. Do not hand your AI assistant your RunPod key or payment details unless you accept that it can spend money.
- Template: RunPod's official public template list includes "Runpod Ubuntu 24.04", a CPU template with SSH, a Jupyter port (8888) and a 10 GB container disk [24]. That is where we would start. We have not yet booted it, so we do not know that Jupyter runs on it or that the KiCad install steps work in it.
- Reaching the pod: the console's web terminal, the Jupyter terminal, or SSH [31]. RunPod says the web terminal is not recommended for long-running processes. Wait until the pod is really ready before you connect; "Running" can appear before services are up [32].
- Browser desktop: optional, and we would avoid it at first. The headless route (your assistant runs
kicad-cli; you look at exported images) exposes nothing. If you do want KiCad in a browser, one candidate image,linuxserver/kicad, has no login by default, and its web terminal has passwordless sudo, so anyone who reaches the page gets full control of the container [37]. Set a password with itsCUSTOM_USERandPASSWORDsettings. We have not tested it on RunPod. - Public web addresses: a pod's HTTP proxy address is public, has no login, and times out requests after 100 seconds [32]. Do not put files or a desktop on one unless you accept that anyone with the address can reach it.
- Files vanish: container disk is erased when the pod stops, and a CPU pod has no persistent volume disk [23][22]. A network volume survives, but it keeps billing until you delete it [34]. So download your files first.
- Getting files out: the Jupyter file browser,
runpodctl sendandreceive[36], orscpandrsyncover SSH [35]. Ask your assistant to zip the output folder so there is one file to download. We have not tested an iPad-only route.
Stop is not terminate. RunPod's documented storage charges [23]:
| Storage | Running pod | Stopped pod |
|---|---|---|
| Container disk | $0.10 per GB per month | Not charged, but erased when the pod stops |
| Volume disk (not available on CPU pods) | $0.10 per GB per month | $0.20 per GB per month |
| Network volume | $0.07 per GB per month (under 1 TB) | $0.07 per GB per month |
A stopped pod can still bill for a volume disk, and RunPod's guidance is to terminate rather than stop to end all charges [33]. Terminating deletes the disk [34]. What exactly happens to a stopped CPU pod that has no network volume is something we have not tested, so the simple rule is: download the files, then terminate.
6. Prompts to give your AI assistant
Paste the first box at the start of every conversation, then use the numbered prompts. Replace the parts in [brackets]. Every prompt tells the assistant to ask before spending money and to shut things down afterwards. Keep that rule.
Paste this first: the ground rules
Rules for this session: (1) Never create, start, resize or restart anything that costs money, and never create an account, without first telling me what it is, the hourly price and the total I could be charged, and getting my explicit "yes". (2) Do not invent prices, stock levels, part numbers or quotes. If you do not know, say "unknown" and tell me where to look. (3) Do not claim a board is correct. Say what was checked and what was not. (4) When we finish, list the files to download, wait until I confirm I have them, then ask me to confirm before stopping or terminating the pod. Remind me that terminating ends billing and deletes the disk.
You should get: an acknowledgement of the four rules. Check: the first time it wants to start anything that costs money, it asks you first.
Prompt 1: set up the tools
You have a shell on a fresh RunPod CPU pod (Ubuntu 24.04). Install KiCad 10 from the official KiCad team package archive (ppa:kicad/kicad-10.0-releases), plus ngspice and Python 3 with pip. Install a Java runtime only if I ask for Freerouting. Before installing anything, tell me what you plan to install and how much disk it needs, and ask me before anything that costs money. Then show the output of `kicad-cli --version`, `ngspice -v`, and `python3 -c "import pcbnew"`. If a step fails, show me the exact error and what you tried. Do not change anything except these installs and files in the project folder.
You should get: a working kicad-cli (version 10.0.x) and ngspice, with an honest report of whether the Python pcbnew module imports. Check: you can see the real version strings in the output. If import pcbnew fails, accept that rather than letting the assistant hide it.
Prompt 2: design a simple board from a plain description
Design a small board in KiCad, as a project folder `led-board/`. Spec: powered from a 5 V USB connection, one power LED with a series resistor sized for about 5 mA, a 2-pin header for 5 V and GND, two M3 mounting holes, board about 30 x 20 mm, two layers. Use only parts and footprints from KiCad's standard libraries. Before drawing, give me a table of each part: reference, value, symbol, footprint, and the datasheet or library page you used for the pin numbers. Show your calculation for the resistor, with the LED forward voltage you assumed and where that number came from. Stop and ask me if a number is unknown. Do not make mains-voltage or battery circuits. Ask me before anything that costs money.
You should get: project files (.kicad_pro, .kicad_sch, .kicad_pcb) and a parts table. Check: confirm the LED's anode and cathode and the resistor value yourself, then run the checks in Prompt 4 and look at an exported image.
Prompt 3: review an existing KiCad project
Review the KiCad project in `~/project/`. Do not modify any file. Run `kicad-cli sch erc` and `kicad-cli pcb drc` with `--exit-code-violations`, and show me the full reports. Then list every footprint with its reference, value and footprint name, and every net with fewer than two connections. Flag anything that looks like a pin-number mismatch, reversed polarity, a missing decoupling capacitor, or a trace carrying more current than its width suggests, and for each flag say how sure you are. Finish with a list of things you cannot check without the datasheets, and ask me for those datasheets. Ask me before anything that costs money.
You should get: a read-only report with the raw ERC and DRC output and a list of questions. Check: the project files are unchanged (compare timestamps), and you read the raw reports yourself, not only the summary.
Prompt 4: run ERC and DRC and fix what is safe to fix
In `led-board/`, run the schematic ERC and the board DRC from the command line with `--exit-code-violations`. Save the reports. Fix only violations that are clearly mechanical (for example silkscreen overlap or a missing board outline) and tell me each change. For anything electrical, do not fix it silently: explain it and ask me. Rerun until the exit code is 0, or until only items you have explained to me remain. Tell me whether any checks were ignored or set to "ignore" in the project settings. Ask me before anything that costs money.
You should get: ERC and DRC reports before and after, with a change log. Check: exit code 0 from both commands, and open the project's rule settings (or have the assistant print them) to see that nothing was switched off. Remember that a clean report does not prove the board works.
Prompt 5: check footprints against datasheets
For every footprint on the board in `led-board/`, create a 1:1 scale PDF of the footprints (a real-size printout I can place parts on), using `kicad-cli pcb export pdf`. For each part, give me the exact datasheet link or library entry name for its land pattern, and list the pad pitch, pad size and pin 1 position you used. If you cannot cite a source for a dimension, mark it UNVERIFIED. I will print the PDF at 100% and check the real parts. Ask me before anything that costs money.
You should get: a printable PDF and a table of dimensions with sources. Check: print at 100% (not "fit to page"), measure the printout with a ruler or calipers, and lay the real components on the paper.
Prompt 6: generate the files a board maker needs
In `led-board/`, generate the fabrication files with `kicad-cli`: Gerbers for all used layers, drill files, and a component position file; also export a BOM from the schematic. Put them in `fab/`, and make `led-board-fab.zip`. Check `kicad-cli pcb export gerbers --help` for the correct options for my KiCad version rather than guessing. List every file and its layer. Then ask me which fab I use and ask for their file requirements instead of guessing. Ask me before anything that costs money. When we are done, remind me to download the zip and to terminate the pod.
You should get: a fab/ folder and a zip with one file per layer, a drill file, a position file and a BOM. Check: open the Gerbers in a separate third-party viewer, confirm the outline is a closed shape, holes line up with pads and silkscreen is readable, and compare the file list with the fab's stated requirements.
Prompt 7: estimate the cost
Estimate what this project costs me. Part 1, RunPod: using only the hourly rate I give you ([paste the hourly price shown in the RunPod Summary panel here]) and the time we have used so far, compute the compute cost, and add the container disk charge at $0.10 per GB per month for the disk size I chose. Show the arithmetic. Part 2, board and parts: do NOT guess prices. Tell me the board size, number of layers and quantity, give me the BOM as a table, and tell me which fab quote page and which parts-supplier page I should check myself. Part 3: list the other things that could cost money (shipping, assembly, stencil, import tax) and mark each "unknown". Do not start or change anything that costs money.
You should get: a pod cost computed from your own numbers and a checklist for the board cost you get yourself. Check: redo the arithmetic, compare with RunPod's Billing page, and get the board quote from the fab's own site.
Prompt 8: wrap up and stop paying
We are finished. List every file in `led-board/` and `fab/` that I should download, with sizes. Zip them into one file and tell me how to download it from this pod (the Jupyter file browser, or whichever method we set up). Wait for me to say I have downloaded and opened it. Then tell me exactly what terminating this pod will delete, and ask me to confirm. After I confirm, terminate the pod (not just stop it) if you have permission, or give me the exact console steps. Finally, check that no pod or network volume from this session is still running or billing, and tell me what you found.
You should get: one zip downloaded to your device, then the pod terminated. Check: the RunPod pods page lists no pod from this session, the network volumes page shows no volume you did not mean to keep, and the Billing page shows the final charge.
7. Keep it safe
- Never order a board you have not reviewed. Complete, plausible-looking projects were mostly not functional in the benchmark above [26]. Footprint and pin mistakes are the common failure, so check footprints at 1:1 and pins against the manufacturer's datasheet, not your assistant's memory.
- Mains voltage is not a beginner project. Safe spacing for mains circuits comes from safety standards, not from generic board rules. One summary notes that IPC-2221 is a functional spacing guide and not a safety requirement, and that published figures conflict between web sources, so treat any number your assistant gives you as unverified [38]. Mains boards need review by someone qualified.
- Lithium batteries are not a beginner project either. Adafruit's guide describes lithium-ion and lithium-polymer cells as powerful but not inherently safe, recommends protected cells, and warns that misuse can hurt you or your property. Battery University says lithium-ion packs require a protection circuit [39]. Do not let your assistant choose a charger or protection design without you checking the datasheets.
- Do not claim certification (CE, FCC, UL). Nothing in this guide provides it.
- Do not let your assistant invent prices, stock or quotes. Get them from the fab and parts-supplier pages.
- A pod is not a vault. Its public web addresses have no login, and a browser desktop may have none either. Set a password, do not leave a desktop running unattended, and keep your own copy of anything you need. RunPod says pods are not designed for long-term storage of critical data [23].
- You pay while it runs. A forgotten pod keeps billing. Terminate when finished and check the pod list.
- Never paste your RunPod key or card details into a chat tool or a file.
8. What we have not tested yet
This guide is built from documentation, release pages and a benchmark paper, not from a finished board of our own. So far we have read a great deal and soldered nothing. Nothing we read shows a board built, made and powered up with this exact set of tools. Before we call anything proven, these still need a real hands-on test:
- That the Ubuntu 24.04 CPU template boots, that its web terminal opens (from a desktop browser and from an iPad), and that the KiCad 10 install works in it.
- That the command-line checks and exports (ERC, DRC, Gerbers, drill, positions, BOM and the 3D render) all run with no display attached and return the documented exit codes.
- Whether KiCad's Python module loads on that install, and whether the newer scripting interface still needs a running copy of KiCad in KiCad 10.
- How much memory and time the full flow needs, and so what pod size to pick.
- Freerouting on a pod: which Java version installs, and whether a script can route a board without opening KiCad.
- SKiDL, atopile and tscircuit: installing them on a pod and checking that they produce usable files without a graphical interface.
- Downloading files from a CPU pod (Jupyter file browser,
runpodctl, a file browser template), including an iPad-only route. - What a stopped CPU pod without a network volume actually keeps, and what billing remains after stop versus terminate.
- A browser desktop running KiCad as a custom template, with a password set.
- An AI assistant driving the pod end to end: which assistants can reach a shell, and whether they keep the "ask before spending" rule.
- A real small board built, manufactured and powered up.
- The actual CPU pod price in the console on the day of the test.
When we run these, we will publish the measurements with the date, the hardware and the bill.
Next: get it made
A board maker turns your files into real boards. These are places people commonly use. We earn nothing from these links, and we have not ordered from them ourselves. Prices change, so get the price on each maker's own quote page. Some public reviews (Trustpilot, read within the last 30 days) of the two biggest, JLCPCB and PCBWay, mention refund and shipping problems, so start with a small order.
- OSH Park (USA): takes your KiCad board file directly. Bare boards only.
- AISLER (Europe): takes your KiCad file directly. Boards, and assembly if you want it.
- Eurocircuits (Europe): checks your file for problems before you pay.
- JLCPCB and PCBWay (China): boards and assembly with an instant quote. Allow for shipping and import charges.
What to have ready
- One zip file with your Gerber files: one file per layer (top copper, bottom copper, the two solder-mask layers, the printed labels, and the board outline).
- The drill file, inside the same zip.
- Only if you are paying them to solder parts on: the parts list (BOM) and the position file (also called CPL, pick-and-place or centroid).
- The board size in millimetres and the number of layers, so you can check the quote page read your files correctly.
Before you order
- The two automatic checks (ERC and DRC) pass, or you understand every warning that is left.
- You opened the Gerber zip in a separate viewer, and looked at the maker's own preview. The outline is one closed shape. Holes sit in the middle of pads.
- The size on the quote page matches your board in millimetres. The layer count matches.
- You printed the board at 1:1 on paper and laid the real parts on it, or checked each footprint against its datasheet.
- Polarity marks and pin 1 are right for every part that has a direction.
- First board: no mains voltage, no lithium batteries, smallest quantity, no paid assembly.
- You read the full total on the checkout page, including shipping. Import duty or courier fees may be charged later; the page may not show them.
- You placed the order yourself. Do not let an assistant enter payment details or press the order button.
- You kept a copy of the exact zip you uploaded.
Want a pod for the browser-only route?
Make a RunPod account and add a small balance such as $10, or paste this into your AI assistant: Read agents.runpod.io and set up Runpod for me. Then use Prompt 1 above. Check the price per hour in the console before you deploy.
Referral link: we may earn credits if you sign up.
Sources
- KiCad source mirror (license GPL-3.0 and others): github.com/KiCad/kicad-source-mirror
- KiCad release tags: gitlab.com/kicad/code/kicad
- KiCad 10.0 command-line reference: docs.kicad.org/10.0/en/cli
- SKiDL documentation: devbisme.github.io/skidl
- SKiDL repository (MIT): github.com/devbisme/skidl
- SKiDL on PyPI (version 3.0.0): pypi.org/pypi/skidl
- atopile repository (MIT): github.com/atopile/atopile
- atopile releases: github.com/atopile/atopile/releases
- atopile documentation and PyPI listing: docs.atopile.io, pypi.org/pypi/atopile
- tscircuit repository (MIT): github.com/tscircuit/tscircuit
- tscircuit documentation: docs.tscircuit.com
- Freerouting repository (GPL-3.0, README and releases): github.com/freerouting/freerouting
- Freerouting command-line arguments: github.com/freerouting/freerouting (docs). KiCad integration: integrations.md
- ngspice (license and version, per Wikipedia): en.wikipedia.org/wiki/Ngspice. Download page: ngspice.sourceforge.io/download
- ngspice tutorial (batch mode): ngspice.sourceforge.io/ngspice-tutorial
- KiCad 9.0 command-line manual (the
export gerberdeprecation): docs.kicad.org/9.0/en/cli - KiCad developer docs, pcbnew Python bindings (deprecated): dev-docs.kicad.org
- KiCad IPC API, and an article on using it in CI (written against KiCad 9.0.0): dev-docs.kicad.org (IPC API), adamws.github.io
- Ubuntu 24.04 package list entry for KiCad (7.0.11): packages.ubuntu.com/noble/kicad
- KiCad 10.0 releases package archive (Ubuntu 24.04 build 10.0.8): launchpad.net/~kicad
- KiCad Docker images (for
kicad-cli; GUI not supported): kicad.org/download/docker - RunPod docs, CPU pods (concept description from the API reference): docs.runpod.io/api-reference-v2/overview
- RunPod docs, Pod pricing and storage: docs.runpod.io/pods/pricing
- RunPod catalog and official public template list, read through RunPod's API tools within the last 30 days (RTX 3090 rates; template ids, images and ports). This is RunPod catalog data, not a public page.
- RunPod docs, Get started (account steps, two-factor authentication, deploy Summary panel with cost per hour): docs.runpod.io/get-started
- EDA Bench, ICML 2026 listing (abstract): icml.cc/virtual/2026/77908
- PCEval, language models and physical circuit layout: arxiv.org/html/2601.02404
- JLCPCB, how to generate Gerber and drill files in KiCad: jlcpcb.com/help
- KiCad 10.0 schematic editor manual (ERC): docs.kicad.org/10.0/en/eeschema
- KiCad 10.0 PCB editor manual (DRC): docs.kicad.org/10.0/en/pcbnew
- RunPod docs, Connect to a pod (web terminal, JupyterLab, SSH): docs.runpod.io/pods/connect-to-a-pod
- RunPod docs, Expose ports (public proxy address, 100-second timeout, readiness): docs.runpod.io/pods/configuration/expose-ports
- RunPod docs, Manage pods (billing after stop versus terminate): docs.runpod.io/pods/manage-pods
- RunPod docs, Storage types (volume disk and network volume lifecycle): docs.runpod.io/pods/storage/types
- RunPod docs, Transfer files (scp and rsync): docs.runpod.io/pods/storage/transfer-files
- RunPod docs,
runpodctl send: docs.runpod.io/runpodctl/reference/runpodctl-send - linuxserver.io, KiCad in a browser desktop (no login by default, passwordless sudo): docs.linuxserver.io/images/docker-kicad
- Summaries of clearance and creepage for high-voltage boards (vendor and blog pages, not the standards themselves): byte-lab.com, vse.com
- Adafruit, lithium-ion and lithium-polymer batteries: learn.adafruit.com. Battery University, making lithium-ion safe: batteryuniversity.com
Licence, version and rate information was read within the last 30 days and can change; check each page before you rely on it. GPU rates are RunPod on-demand rates from its API. Product names belong to their owners and are used only to describe what they are.