easyeda2kicad.py: Convert LCSC and EasyEDA Parts to KiCad

Why easyeda2kicad.py bridges the LCSC-to-KiCad gap

easyeda2kicad.py addresses the repeated work involved when a PCB design uses an LCSC component and the available EasyEDA data does not match the user's KiCad library. The project converts component data from EasyEDA or LCSC into a KiCad library containing a symbol, a footprint, and 3D models. The README specifically presents the workflow as useful for JLCPCB SMT assembly services, where a design may need library assets that correspond to purchasable components.

The target user is a PCB designer working with KiCad v6 or newer who already has an LCSC part number or access to EasyEDA component data. The `--lcsc_id` examples use identifiers such as `C2040`, `C20197`, and `C163691`. This is not a general-purpose component selector or PCB design assistant. Its job begins after the component has been identified and ends when library files are written to disk.

The generated library has a conventional KiCad directory structure. A default conversion produces `easyeda2kicad.kicad_sym`, an `easyeda2kicad.pretty/` footprint directory, and an `easyeda2kicad.3dshapes/` model directory. Models are documented as being saved in both `.WRL` and `.STEP` formats. That combination is more useful than importing only a schematic symbol because a KiCad design also needs land pattern data, while enclosure checks and board visualization can use the generated model files.

The project does not present itself as a substitute for component verification. Source geometry may come from EasyEDA or LCSC data, and the README provides fallback behavior for a missing datasheet URL, but it does not claim that every generated asset has been checked against the manufacturer drawing or assembly rules. The conversion saves setup effort, not engineering responsibility.

The conversion path behind `--full` and individual asset flags

The visible CLI design treats conversion as a selectable pipeline. `--full` requests a symbol, footprint, and 3D model. `--symbol`, `--footprint`, and `--3d` request individual outputs. `--svg` is separate because it produces an SVG preview without performing a KiCad conversion. This makes it possible to update one kind of asset without replacing a complete library entry.

Based on the repository layout, the installed package contains the converter behind the `easyeda2kicad = easyeda2kicad.__main__:main` console entry point. The documentation also refers to EasyEDA format documentation, including `docs/CMD_FOOTPRINT.md` for footprint commands and `docs/CMD_SYMBOL.md` for symbol commands. Those references indicate that the package handles command-based EasyEDA geometry rather than merely copying a finished KiCad file. The README excerpt does not expose the internal class structure or the complete conversion sequence, so the exact parsing calls should not be inferred beyond that documented model.

Output behavior is controlled at the library level. `--output` places the symbol beside the named library as `<name>.kicad_sym`, footprints under `<name>.pretty/`, and models under `<name>.3dshapes/`. The README says missing files and directories are created. Existing assets are not silently replaced by default. `--overwrite` permits replacement of an existing symbol, footprint, or 3D model.

Custom symbol properties can be added with `--custom-field`. Each value uses a `key:value` form, malformed values stop processing, and duplicate keys resolve to the last value. If EasyEDA does not supply a datasheet URL, the documented fallback is `https://www.lcsc.com/datasheet/<LCSC-ID>.pdf`. This fallback supplies a path to relevant documentation, but it does not mean the linked document was validated against the generated footprint.

Installing easyeda2kicad.py and generating the first library

For a system Python installation, the documented starting point is the PyPI package. The package declares Python 3.9 or newer and provides the `easyeda2kicad` command.

pip install easyeda2kicad

After installation, perform a full conversion for the README's `C2040` example. This requests the symbol, footprint, and 3D models in the default library location.

easyeda2kicad --full --lcsc_id=C2040

On Linux and macOS, the README gives the default location as `~/Documents/Kicad/easyeda2kicad/`. On Windows, it gives `C:/Users/your_name/Documents/Kicad/easyeda2kicad/`. The reader should find `easyeda2kicad.kicad_sym`, `easyeda2kicad.pretty/`, and `easyeda2kicad.3dshapes/` there.

KiCad installations that bundle Python require platform-specific handling. On Windows, the README says to use the KiCad Command Prompt and install the package there. Since KiCad's Scripts folder is not on `PATH`, it gives a module invocation for running the tool.

python -m easyeda2kicad

On macOS, the documented bundled interpreter is invoked directly for installation.

/Applications/KiCad/KiCad.app/Contents/Frameworks/Python.framework/Versions/Current/bin/python3 -m pip install easyeda2kicad

The Linux instructions state that most distributions use the system Python, so the regular `pip install easyeda2kicad` command works directly. This operating-system split is the first practical compatibility check.

Selecting outputs, destinations, and repeatable batch conversions

The CLI supports several useful scopes. A designer can create only a symbol, only a footprint, or only a 3D model by changing the output flag while retaining the same LCSC identifier. This is appropriate when a symbol already exists but a missing asset must be added.

Several identifiers can be passed in one invocation. The following documented command creates complete assets for three components.

easyeda2kicad --full --lcsc_id C2040 C20197 C163691

For a project-owned library, `--output` changes the library stem and destination. The README maps that one argument to three outputs: a `.kicad_sym` file, a `.pretty/` directory, and a `.3dshapes/` directory.

easyeda2kicad --full --lcsc_id=C2040 --output ~/libs/my_lib

Existing entries are protected unless replacement is requested.

easyeda2kicad --full --lcsc_id=C2040 --output ~/libs/my_lib --overwrite

`--overwrite` should be used deliberately because it applies to any matching symbol, footprint, or 3D model already present. The README does not describe backups, merge conflict resolution, or rollback. A user who needs a preserved library revision must arrange that separately.

Custom fields can carry design metadata that is not present in the generated symbol. The key and value must be separated by a colon.

easyeda2kicad --symbol --lcsc_id=C2040 --custom-field "Manufacturer:Texas Instruments" "Package:LQFN-56"

Malformed fields fail fast, while duplicate keys use the last value. That policy makes accidental overwrites within a command predictable, but it also means field ordering can affect the final symbol.

Portable 3D paths, proxies, caching, and SVG inspection

Absolute model paths can prevent a KiCad project from moving cleanly between machines. `--project-relative` changes generated 3D references to use `${KIPRJMOD}`. It must be combined with `--output`.

easyeda2kicad --full --lcsc_id=C2040 --output ~/myproject/libs/my_lib --project-relative

The README states that the stored path takes the form `${KIPRJMOD}/libs/my_lib.3dshapes/...`, rather than retaining an absolute filesystem location. This is a project portability feature, not a change to the model format. The `.wrl` and `.STEP` outputs described by the project remain separate assets.

For users behind an HTTP proxy, the tool reads the standard `HTTPS_PROXY` environment variable rather than requiring a dedicated CLI option. The documented shell syntax differs by platform.

HTTPS_PROXY=http://proxy.example.com:8080 easyeda2kicad --full --lcsc_id=C2040

On Windows, the README gives this form.

set HTTPS_PROXY=http://proxy.example.com:8080 && easyeda2kicad --full --lcsc_id=C2040

`--use-cache` stores API responses under `.easyeda_cache/` and is described as supporting faster, offline-capable runs. `--debug` adds verbose logging. Combining both is useful when diagnosing a cached lookup, although the README does not define cache expiration or authentication behavior.

easyeda2kicad --full --lcsc_id=C2040 --use-cache --debug

The documented cache removal command deletes the complete local cache directory.

rm -rf .easyeda_cache

For geometry inspection without a KiCad conversion, `--svg` writes a preview to the selected output location.

easyeda2kicad --svg --lcsc_id=C2040 --output ~/libs/my_lib

This preview is useful before committing a footprint, but the README does not specify its units, rendering conventions, or whether every source layer is represented.

Registering the generated libraries with KiCad 6 and newer

The README requires at least one conversion before configuring KiCad because the script creates the library files. A symbol-and-footprint command is sufficient to create the directories needed for the documented default-library configuration.

easyeda2kicad --symbol --footprint --lcsc_id=C2040

After that, KiCad users add the generated location to the path configuration. The README calls for an environment variable named `EASYEDA2KICAD`. Its examples point to the default user Documents directories on Windows and Linux.

The symbol library entry resolves to:

${EASYEDA2KICAD}/easyeda2kicad.kicad_sym

The footprint library entry resolves to:

${EASYEDA2KICAD}/easyeda2kicad.pretty

These paths are added through KiCad's Preferences, specifically Configure Paths, Manage Symbol Libraries, and Manage Footprint Libraries. The project supports KiCad v6 and newer, but the README excerpt does not describe version-specific migration behavior for libraries created by earlier easyeda2kicad versions.

A custom `--output` library requires equivalent KiCad path entries. The generated `.kicad_sym`, `.pretty/`, and `.3dshapes/` assets are separate libraries, so adding only the footprint directory will not make the symbol available through the symbol library manager. For a project stored under version control, `--project-relative` reduces one class of path dependency, but the README does not document an automated KiCad project-file update.

Maintenance, release state, and AGPL-3.0 implications

The repository is not archived, and its last push was on 2026-04-08. The newest listed release is `v1.0.1`, dated 2026-04-06. Those dates indicate recent development activity around that release, but they do not by themselves establish compatibility with every future EasyEDA, LCSC, KiCad, or Python release. The README also does not publish a migration guide or rollback procedure for `v1.0.1`.

The package declares no mandatory runtime dependencies in `setup.py`, with an empty `install_requires` list. It requires Python 3.9 or newer and is marked as platform-independent. The `dev` extra contains `pre-commit>=3.0.0`; the top-level `requirements.txt` also lists `pre-commit>=3.0.0`. This keeps basic installation narrow, although network access is still relevant when obtaining component data unless the cache already contains the required response.

The project is licensed under `AGPL-3.0`. That identifier matters when deciding whether generated files or modified versions can be distributed under particular terms, and when determining whether network deployment triggers source-offer obligations. The repository information identifies the license but does not provide legal interpretation. Users responsible for compliance should examine the actual `LICENSE` file and their distribution or hosting model rather than assuming that the Python command-line interface is categorically exempt or covered.

Upgrade evaluation should also account for the library files already in use. `--overwrite` can replace generated assets, and the README does not describe a built-in restore mechanism. Existing KiCad projects should therefore preserve their current symbol, footprint, and project files before applying a new package version to the same output library.

easyeda2kicad.py versus manual KiCad library authoring

The practical alternative is manual asset creation in KiCad using EasyEDA or LCSC data as the source. That approach gives the designer direct control over every symbol field, pad definition, courtyard, silkscreen element, and model reference. Its cost is repeated work and the need to compare the KiCad result with component documentation. easyeda2kicad.py takes the opposite approach by deriving several asset classes from the upstream component data in one command.

The converter is the better fit when several PCB projects use LCSC identifiers, KiCad v6 or newer is the target environment, and consistency across generated symbol, footprint, and model files matters. Its selection flags, batch identifier input, shared output layout, cache, and `--project-relative` option reduce repetitive setup. The generated KiCad `.kicad_sym` and `.pretty/` formats also fit KiCad's normal library management model.

Manual authoring is preferable when a part uses custom symbol logic, has mechanical requirements that the upstream representation does not capture, or needs pad and courtyard decisions verified against a manufacturer package drawing. The README does not document a validation report, pin-map warning system, or certification process. It also describes `--svg` only as a preview and does not promise manufacturing validation.

The main boundary is source authority. easyeda2kicad.py reduces conversion work, but it cannot establish that the source data is correct for a specific package variant. The LCSC identifier, selected EasyEDA representation, generated footprint geometry, and manufacturer documentation must be treated as separate points of verification before production output is released.

Editorial conclusion

Adopt easyeda2kicad.py when you repeatedly import identifiable LCSC or EasyEDA parts into KiCad 6 or newer, especially when assembly parts need symbols, footprints, and colored 3D models. Do not treat generated output as verified manufacturing data: inspect pin mapping, footprint geometry, datasheet fields, and 3D placement before schematic release. The first upgrade check should focus on the recent v1.0.1 package and the repository's AGPL-3.0 obligations.

Frequently asked questions

Official sources

1. Issues
2. License: AGPL-3.0
3. README
4. Releases
5. uPesy/easyeda2kicad.py on GitHub