#!/bin/bash # Build a KiCad app (pcbnew, eeschema, calculator, pl_editor) for WebAssembly. # # Usage: # ./scripts/kicad/build-kicad-target.sh [options] # # Args: # pcbnew | eeschema | calculator | pl_editor (required) # # Options: # --full Full clean rebuild (dependencies + KiCad) # --clean-kicad Clean only KiCad build directory (not deps) # --build-deps Build dependencies (default: skip) # --debug Build with debug symbols (default) # --release Build optimized without debug symbols # --diag=... Diagnostic preprocessor flags (gal, coroutine, ctor, all) # -j N Parallel compilation jobs (default: 1) # # Each app builds into its own tree: build-wasm/kicad-/. # Per-app extras live alongside generic stubs: # - wasm/bindings/_embind.cpp (optional) # - wasm/stubs/_frame_stub.cpp (optional, app-specific stubs) # - wasm/stubs/_scripting_stub.cpp (optional, app-specific scripting stubs) # # Most apps use the same name for the user-facing app, the CMake target, and # the source subdirectory. Calculator is the exception: app=calculator but the # upstream target and source subdir are both pcb_calculator (the OUTPUT_NAME # property in pcb_calculator/CMakeLists.txt emits calculator.{js,wasm}). # pl_editor is the standard case but its source subdir is pagelayout_editor. set -e if [ -z "$1" ]; then echo "Error: missing argument (kicad_editor | pcbnew | eeschema | calculator | pl_editor | gerbview)" >&2 exit 1 fi APP_NAME="$1" shift # KICAD_TARGET: the CMake/make target name. # KICAD_SUBDIR: the source/build subdirectory the target's artifacts land in. # Most apps share all three names; the exceptions: # - calculator: target+subdir are both pcb_calculator (OUTPUT_NAME=calculator) # - pl_editor: subdir is pagelayout_editor (upstream source dir name) # The footprint/symbol editors have no target of their own — the pcbnew/eeschema # bundle opens them at runtime via single_top.cpp's --frame flag. case "$APP_NAME" in kicad_editor) # Merged pcbnew+eeschema image (editor-unification Part 2): one executable # linking BOTH kifaces, frame chosen at runtime by --frame (pcb/fpedit/sch/ # symedit). Target lives in wasm/editor/ (added by the fork's top-level # CMakeLists under -DKICAD_WASM_MERGED_EDITOR=ON); its binary dir doubles as # the artifact subdir. KICAD_TARGET="kicad_editor" KICAD_SUBDIR="kicad_editor" ;; pcbnew|eeschema|gerbview) KICAD_TARGET="$APP_NAME" KICAD_SUBDIR="$APP_NAME" ;; pl_editor) KICAD_TARGET="pl_editor" KICAD_SUBDIR="pagelayout_editor" ;; calculator) KICAD_TARGET="pcb_calculator" KICAD_SUBDIR="pcb_calculator" ;; sym_convert) # Standalone .lib -> .kicad_sym converter (node CLI). Its add_executable # lives in eeschema/CMakeLists.txt (gated by KICAD_SYM_CONVERTER_WASM), so # artifacts land in the eeschema/ subdir of its own kicad-sym_convert tree. KICAD_TARGET="sym_convert" KICAD_SUBDIR="eeschema" ;; occ_service) # Standalone OpenCASCADE 3D service (worker embind module). Target lives # in wasm/occ-service/ (added by the fork's top-level CMakeLists under # -DKICAD_OCC_SERVICE_WASM=ON); like kicad_editor, its binary dir # doubles as the artifact subdir of its own kicad-occ_service tree. KICAD_TARGET="occ_service" KICAD_SUBDIR="occ_service" ;; *) echo "Error: unknown app '$APP_NAME' (expected: kicad_editor | pcbnew | eeschema | calculator | pl_editor | gerbview | sym_convert | occ_service)" >&2 exit 1 ;; esac # Which app's embind bindings to compile + link. Most apps use their own; the # sym_convert CLI links the eeschema kiface objects, which reference eeschema's # embind symbols (kicadCollabOnSave et al.) — reuse eeschema's embind object. case "$APP_NAME" in sym_convert) EMBIND_APP="eeschema" ;; # occ_service links the pcbnew kiface objects → pcbnew's embind object, same # reason (its own embind entry points live in occ_service_main.cpp, compiled # inside the CMake target). occ_service) EMBIND_APP="pcbnew" ;; *) EMBIND_APP="$APP_NAME" ;; esac # Which app's WASM stub libraries (scripting/frame placeholders) to link. # sym_convert links the eeschema kiface objects, so it needs eeschema's frame # stub (eeschema_frame_stub.cpp). kicad_editor links pcbnew's kiface objects, which # reference the action-plugin scripting placeholders (pcbnewGet*); eeschema's frame # stub arrives via CMake (target_sources on eeschema_kiface_objects), not this path. case "$APP_NAME" in sym_convert) STUB_APP="eeschema" ;; kicad_editor) STUB_APP="pcbnew" ;; # occ_service links the pcbnew kiface objects → pcbnew's stubs (frame + # action-plugin scripting placeholders), like the editors. occ_service) STUB_APP="pcbnew" ;; *) STUB_APP="$APP_NAME" ;; esac SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" source "${SCRIPT_DIR}/../common/env.sh" source "${SCRIPT_DIR}/../common/versions.sh" source "${SCRIPT_DIR}/../common/functions.sh" source "${SCRIPT_DIR}/../common/stages.sh" KICAD_DIR="${PROJECT_ROOT}/kicad" WASM_LAYER="${PROJECT_ROOT}/wasm" KICAD_BUILD="${BUILD_ROOT}/kicad-${APP_NAME}" KICAD_STAMP="${BUILD_ROOT}/stamps/kicad-${APP_NAME}.stamp" WX_BUILD="${BUILD_ROOT}/wxwidgets" # Parse arguments - incremental build by default (optimized for development) NO_CLEAN=1 FULL_CLEAN=0 SKIP_DEPS=1 DEBUG=0 DIAG_LIST="" while [[ $# -gt 0 ]]; do case $1 in --full) FULL_CLEAN=1 NO_CLEAN=0 SKIP_DEPS=0 shift ;; --clean-kicad) NO_CLEAN=0 shift ;; --build-deps) SKIP_DEPS=0 shift ;; --debug) DEBUG=1 shift ;; --release) DEBUG_BUILD=0 export DEBUG_BUILD shift ;; --diag=*) DIAG_LIST="${1#--diag=}" shift ;; --diag) DIAG_LIST="$2" shift 2 ;; -j) export JOBS="$2" shift 2 ;; -j*) export JOBS="${1#-j}" shift ;; *) shift ;; esac done # Diagnostic preprocessor defines from --diag= (gal, coroutine, ctor, all). # These gate the KI_DIAG_* macros in kicad/include/kicad_wasm_diag.h. Output goes # to stdout ([KICAD_OUT] logs), never errors. Off by default. DIAG_DEFINES="" if [ -n "${DIAG_LIST}" ]; then IFS=',' read -ra _diag_cats <<< "${DIAG_LIST}" for _cat in "${_diag_cats[@]}"; do case "${_cat}" in gal) DIAG_DEFINES="${DIAG_DEFINES} -DKICAD_DIAG_GAL=1" ;; coroutine) DIAG_DEFINES="${DIAG_DEFINES} -DKICAD_DIAG_COROUTINE=1" ;; ctor) DIAG_DEFINES="${DIAG_DEFINES} -DKICAD_DIAG_CTOR=1" ;; all) DIAG_DEFINES="${DIAG_DEFINES} -DKICAD_DIAG_GAL=1 -DKICAD_DIAG_COROUTINE=1 -DKICAD_DIAG_CTOR=1" ;; "") ;; *) log_warn "Unknown --diag category: '${_cat}' (valid: gal, coroutine, ctor, all)" ;; esac done log_info "Diagnostic logging enabled:${DIAG_DEFINES}" fi log_info "Building app: ${APP_NAME}" log_info "Using ${JOBS} parallel jobs" # Step 1: Clean build directories if [ $FULL_CLEAN -eq 1 ]; then log_info "Full clean: removing all stamps and build directories..." rm -rf "${STAMPS_DIR}"/* rm -rf "${BUILD_ROOT}/deps"/* rm -rf "${BUILD_ROOT}/wxwidgets" rm -rf "${BUILD_ROOT}/stubs" rm -rf "${KICAD_BUILD}" rm -rf "${SYSROOT}"/* elif [ $NO_CLEAN -eq 0 ]; then log_info "Cleaning KiCad ${APP_NAME} build directory..." rm -rf "${KICAD_BUILD}" "${KICAD_STAMP}" else log_info "Incremental build (use --clean-kicad or --full to clean)" fi # Step 2: Build dependencies # Note: --with-occ for OpenCASCADE, but NOT ngspice since KICAD_SPICE=OFF if [ $SKIP_DEPS -eq 0 ]; then kw_stage deps log_info "Building dependencies..." "${SCRIPT_DIR}/../deps/build-all-deps.sh" --with-occ else log_info "Skipping dependencies (use --build-deps or --full to build)" fi # Note: We don't check the KiCad stamp here for incremental builds. # CMake handles dependency tracking - it will detect changed source files # and only recompile what's needed. The stamp is created at the end for # scripts that want to know if KiCad was ever built successfully. # Step 4: Build wxWidgets (incremental - only recompiles changed files) kw_stage wxwidgets log_info "Building wxWidgets..." "${SCRIPT_DIR}/../build-wx-wasm.sh" --no-clean log_info "Building KiCad ${APP_NAME} ${KICAD_VERSION} for WASM..." # Step 5: Set build type # Exception model: native WebAssembly exceptions (legacy binary encoding) + wasm setjmp/longjmp, # single-sourced from scripts/common/env.sh (KiCad and wxWidgets must agree — mixing EH models # link-fails / traps; both build with exceptions enabled). -matomics -mbulk-memory are required for # shared memory (pthreads). KICAD_EH_FLAGS="$DEPS_EH_FLAGS" log_info "KiCad EH model flags: ${KICAD_EH_FLAGS}" # Use environment DEBUG_BUILD if set, otherwise check local --debug flag # NOTE: We use -O1 for debug builds because -O0 produces WASM with too many # locals for V8/Chrome to compile (error: "local count too large"). # -O1 keeps debug info but optimizes enough to stay under V8's limits. if [ "${DEBUG_BUILD:-0}" = "1" ] || [ $DEBUG -eq 1 ]; then BUILD_TYPE="Debug" EXTRA_FLAGS="-g -O1 ${KICAD_EH_FLAGS} -matomics -mbulk-memory" # CMake defines DEBUG for Config=Debug (kicad/CMakeLists.txt:351). The embind TU (Step 7) is # compiled OUTSIDE CMake, so it must define DEBUG too — otherwise a DEBUG-gated virtual # (EDA_ITEM::Show, eda_item.h:471) occupies a vtable slot in the core's emitted vtable that the # embind TU doesn't account for, shifting every later slot by one. Then every virtual call made # from the embind TU past that slot (SetWidth/GetPosition/...) reads the wrong vtable offset and # mis-dispatches at runtime (call_indirect signature-mismatch trap; under native-EH the trap is # swallowed by the apply coroutine's catch_all → silent hang). See task #54 root-cause analysis. EMBIND_CONFIG_DEFINES="-DDEBUG" # -gseparate-dwarf puts debug info in a separate .debug.wasm file # This keeps the main WASM small (~200MB) while preserving full debug info # DevTools loads the debug file on-demand when debugging LINKER_DEBUG_FLAGS="-O1 -g -gseparate-dwarf ${KICAD_EH_FLAGS}" log_info "Building KiCad in DEBUG mode (separate DWARF for smaller main binary)" else BUILD_TYPE="Release" EXTRA_FLAGS="-O2 ${KICAD_EH_FLAGS} -matomics -mbulk-memory" EMBIND_CONFIG_DEFINES="" # Release defines no DEBUG in either TU → vtable layouts already match # -O0 at link time skips wasm-opt (which can OOM on large WASM files) # Compilation is still -O2 for optimized code, but we skip post-link wasm-opt LINKER_DEBUG_FLAGS="-O0 ${KICAD_EH_FLAGS}" log_info "Building KiCad in RELEASE mode (skipping wasm-opt due to memory limits)" fi # Step 6: Create build directory mkdir -p "${KICAD_BUILD}" cd "${KICAD_BUILD}" # Step 6.1: Build stub libraries for missing symbols # Generic stubs (libgit2, curl, nng) are shared across apps and built in BUILD_ROOT/stubs. # App-specific stubs (e.g. pcbnew_scripting_stub) build into the same directory but # are only linked in when the corresponding source exists. STUBS_DIR="${PROJECT_ROOT}/wasm/stubs" STUBS_BUILD="${BUILD_ROOT}/stubs" mkdir -p "${STUBS_BUILD}" # ABI-affecting flags shared by EVERY C++ TU compiled OUTSIDE CMake (the embind + the app stubs below). # The core CMake TUs get all of these (DEBUG via Config=Debug -> kicad/CMakeLists.txt:351; # KICAD_USE_PLATFORM_WASM; the char16_t char_traits force-include). A TU that misses any of them can # diverge in vtable layout / ABI from the core — task #54: the embind missing -DDEBUG shifted its vtable # slot offsets by one and hung the collab apply (call_indirect signature-mismatch). Keep them in ONE # place so no out-of-CMake C++ TU can skew again. (EMBIND_CONFIG_DEFINES holds the build-config -DDEBUG, # set in the BUILD_TYPE block above; empty in Release where neither side defines DEBUG.) KICAD_TU_ABI_FLAGS="${EMBIND_CONFIG_DEFINES} -DKICAD_USE_PLATFORM_WASM=1 -include ${STUBS_DIR}/char_traits_uint16_workaround.h" kw_stage kicad-stubs log_info "Building stub libraries..." # Compile libgit2 stub emcc -c "${STUBS_DIR}/libgit2_stub.c" -o "${STUBS_BUILD}/libgit2_stub.o" emar rcs "${STUBS_BUILD}/libgit2_stub.a" "${STUBS_BUILD}/libgit2_stub.o" # Compile curl stub emcc -c "${STUBS_DIR}/curl_stub.c" -o "${STUBS_BUILD}/curl_stub.o" emar rcs "${STUBS_BUILD}/libcurl_stub.a" "${STUBS_BUILD}/curl_stub.o" # Note: the GLU tesselator is provided by kicad/libs/kimath/glu_tess/glu_tess_impl.cpp, # compiled as part of the GAL library (requires KiCad headers). # Compile NNG stub (IPC API requires NNG but sockets don't work in WASM) emcc -c -I"${STUBS_DIR}" "${STUBS_DIR}/nng_stub.c" -o "${STUBS_BUILD}/nng_stub.o" emar rcs "${STUBS_BUILD}/libnng_stub.a" "${STUBS_BUILD}/nng_stub.o" # wx flags for any C++ stubs that include wx headers WX_CXXFLAGS=$("${WX_BUILD}/wx-config" --cxxflags 2>/dev/null || echo "-I${WX_BUILD}/lib/wx/include/emscripten-unicode-static-3.2 -I${PROJECT_ROOT}/wxwidgets/include") # App-specific stubs: # - pcbnew: pcbnew_scripting_stub.cpp (action-plugin scripting placeholders) # - eeschema: eeschema_frame_stub.cpp (placeholder; grows as linker dictates) APP_STUB_LINK="" APP_SCRIPTING_STUB_SRC="${STUBS_DIR}/${STUB_APP}_scripting_stub.cpp" if [ -f "${APP_SCRIPTING_STUB_SRC}" ]; then log_info "Building app scripting stub: ${STUB_APP}_scripting_stub.cpp" em++ -c ${KICAD_TU_ABI_FLAGS} ${WX_CXXFLAGS} "${APP_SCRIPTING_STUB_SRC}" -o "${STUBS_BUILD}/${STUB_APP}_scripting_stub.o" emar rcs "${STUBS_BUILD}/lib${STUB_APP}_scripting_stub.a" "${STUBS_BUILD}/${STUB_APP}_scripting_stub.o" APP_STUB_LINK="${APP_STUB_LINK} ${STUBS_BUILD}/lib${STUB_APP}_scripting_stub.a" fi APP_FRAME_STUB_SRC="${STUBS_DIR}/${STUB_APP}_frame_stub.cpp" if [ -f "${APP_FRAME_STUB_SRC}" ] && [ -s "${APP_FRAME_STUB_SRC}" ]; then log_info "Building app frame stub: ${STUB_APP}_frame_stub.cpp" em++ -c ${KICAD_TU_ABI_FLAGS} ${WX_CXXFLAGS} "${APP_FRAME_STUB_SRC}" -o "${STUBS_BUILD}/${STUB_APP}_frame_stub.o" emar rcs "${STUBS_BUILD}/lib${STUB_APP}_frame_stub.a" "${STUBS_BUILD}/${STUB_APP}_frame_stub.o" APP_STUB_LINK="${APP_STUB_LINK} ${STUBS_BUILD}/lib${STUB_APP}_frame_stub.a" fi log_info "Stub libraries built" # Step 6.2/6.3: wasm-opt + wasm-emscripten-finalize handling. # For the editor apps these tools OOM on the huge debug wasm, so we stub them in # the container and run them on the host (docker/build.sh phase 2). The small, # debug-stripped (-g0) converter finalizes fine in-container, so for sym_convert # we restore/keep the real tools and skip host post-processing entirely. if [ -z "${EMSDK}" ]; then log_error "EMSDK environment variable is not set." exit 1 fi EMSDK_WASM_OPT="${EMSDK}/upstream/bin/wasm-opt" EMSDK_FINALIZE="${EMSDK}/upstream/bin/wasm-emscripten-finalize" if [ "${APP_NAME}" = "sym_convert" ] || [ "${APP_NAME}" = "occ_service" ]; then # Use the real tools so the small -g0 module is fully finalized inside the # container (no host post-processing / asyncify for these targets). [ -f "${EMSDK_WASM_OPT}.real" ] && cp "${EMSDK_WASM_OPT}.real" "${EMSDK_WASM_OPT}" [ -f "${EMSDK_FINALIZE}.real" ] && cp "${EMSDK_FINALIZE}.real" "${EMSDK_FINALIZE}" log_info "Using real wasm-opt/finalize for ${APP_NAME} (finalize in-container)" else if [ -f "${EMSDK_WASM_OPT}" ] && [ ! -f "${EMSDK_WASM_OPT}.real" ]; then log_info "Backing up real wasm-opt..." mv "${EMSDK_WASM_OPT}" "${EMSDK_WASM_OPT}.real" fi # Always copy the latest stub (in case it was updated) cp "${STUBS_DIR}/wasm-opt-stub.sh" "${EMSDK_WASM_OPT}" chmod +x "${EMSDK_WASM_OPT}" log_info "wasm-opt stub installed (asyncify will run on host)" if [ -f "${EMSDK_FINALIZE}" ] && [ ! -f "${EMSDK_FINALIZE}.real" ]; then log_info "Backing up real wasm-emscripten-finalize..." mv "${EMSDK_FINALIZE}" "${EMSDK_FINALIZE}.real" fi # Always copy the latest stub (in case it was updated) cp "${STUBS_DIR}/wasm-emscripten-finalize-stub.sh" "${EMSDK_FINALIZE}" chmod +x "${EMSDK_FINALIZE}" log_info "wasm-emscripten-finalize stub installed (finalize will run on host)" fi # Step 6.5: Verify WASM support is in KiCad fork # The kicad submodule should already have WASM port detection and kiplatform support KICAD_CMAKE="${KICAD_DIR}/CMakeLists.txt" if ! grep -q "msw|qt|gtk|osx|wasm" "${KICAD_CMAKE}"; then log_error "KiCad fork is missing WASM port detection support." log_error "Please ensure the kicad submodule has WASM modifications." exit 1 fi KIPLATFORM_CMAKE="${KICAD_DIR}/libs/kiplatform/CMakeLists.txt" if ! grep -q "KICAD_WX_PORT STREQUAL wasm" "${KIPLATFORM_CMAKE}"; then log_error "KiCad fork is missing kiplatform WASM support." log_error "Please ensure the kicad submodule has WASM modifications." exit 1 fi log_info "KiCad WASM support verified" # Embind object — built after CMake configure runs (so config.h exists). The # linker line below references "${STUBS_BUILD}/${APP_NAME}_embind.o" so we # create an empty placeholder when the source is missing, to keep the link # line stable across apps. # kicad_editor (merged image) links THREE embind objects: both per-editor TUs # (compiled with -DKICAD_MERGED_EMBIND, which compiles out their duplicate # definitions and shared-name registrations) plus the dispatcher TU that registers # the shared JS names once — see wasm/bindings/kicad_editor_embind.cpp. if [ "${APP_NAME}" = "kicad_editor" ]; then EMBIND_OBJ="${STUBS_BUILD}/pcbnew_embind.o ${STUBS_BUILD}/eeschema_embind.o ${STUBS_BUILD}/kicad_editor_embind.o" else EMBIND_OBJ="${STUBS_BUILD}/${EMBIND_APP}_embind.o" fi EMBIND_SRC="${PROJECT_ROOT}/wasm/bindings/${EMBIND_APP}_embind.cpp" # Step 7: Configure KiCad with CMake # We use CMAKE_MODULE_PATH to inject our compatibility layer kw_stage kicad-configure log_info "Configuring KiCad with CMake..." # Use ccache if available (CMAKE_*_COMPILER_LAUNCHER is the proper CMake way) CCACHE_OPTS="" if command -v ccache &> /dev/null; then CCACHE_OPTS="-DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache" log_info "Using ccache for compilation" fi # The standalone converter is a gated eeschema target; enabling the option also # trims the SCH_IO factory to the two KiCad plugins (no pcbjam/http) for this tree. SYM_CONVERTER_CMAKE_FLAG="" if [ "${APP_NAME}" = "sym_convert" ]; then SYM_CONVERTER_CMAKE_FLAG="-DKICAD_SYM_CONVERTER_WASM=ON" fi # Merged pcbnew+eeschema editor: gates the wasm/editor/ subdir, the per-engine # Kiface()/KIFACE_GETTER renames, and the PCB-side ODR symbol renames in the fork's # CMake (see KICAD_WASM_MERGED_EDITOR in kicad/CMakeLists.txt). Only this tree # (build-wasm/kicad-kicad_editor) configures with it ON. MERGED_EDITOR_CMAKE_FLAG="" if [ "${APP_NAME}" = "kicad_editor" ]; then MERGED_EDITOR_CMAKE_FLAG="-DKICAD_WASM_MERGED_EDITOR=ON" fi # The standalone OCC 3D service (worker embind module) — gates the # wasm/occ-service/ subdir in the fork's top-level CMakeLists. OCC_SERVICE_CMAKE_FLAG="" if [ "${APP_NAME}" = "occ_service" ]; then OCC_SERVICE_CMAKE_FLAG="-DKICAD_OCC_SERVICE_WASM=ON" fi # 3D viewer: built by DEFAULT (BUILD_3D_VIEWER=ON). Opt out with BUILD_3D_VIEWER=OFF, which links the # 3D stubs instead. The default renderer is still the GL-free CPU raytracer # (RENDER_3D_RAYTRACE_RAM) blitted through a WebGL2 textured quad, but KiCad's fixed-function # OpenGL renderer (RENDER_3D_OPENGL) now links against the REAL GL1->WebGL2 emulation layer # (wasm/gl1, no -sLEGACY_GL_EMULATION): the shim implements the FFP-only entry points and # --wrap-intercepts the Emscripten-owned names it must observe (wasm/gl1/wrapped_symbols.txt). # Regression gate: tests/3d-regression (47 golden scenarios). The KiCad CMake option # KICAD_BUILD_3D_VIEWER_WASM stays OFF upstream; our build passes it explicitly. # See wasm/gl1/README.md and docs/features/fork-cleanup/10-3d-viewer.md. BUILD_3D_VIEWER="${BUILD_3D_VIEWER:-ON}" GL3D_LINK_FLAGS="" if [ "${BUILD_3D_VIEWER}" = "ON" ]; then log_info "3D viewer ENABLED for WASM (BUILD_3D_VIEWER=ON) — compiling wasm/gl1 FFP shim" GL1_DIR="${PROJECT_ROOT}/wasm/gl1" while IFS= read -r gl1_src; do [ -n "${gl1_src}" ] || continue em++ -c ${EXTRA_FLAGS} -pthread -std=c++20 \ -I"${GL1_DIR}/include" -I"${STUBS_DIR}" -I"${SYSROOT}/include" \ "${GL1_DIR}/src/${gl1_src}" -o "${STUBS_BUILD}/${gl1_src%.cpp}.o" GL3D_LINK_FLAGS="${GL3D_LINK_FLAGS} ${STUBS_BUILD}/${gl1_src%.cpp}.o" done < "${GL1_DIR}/sources.txt" while IFS= read -r gl1_sym; do [ -n "${gl1_sym}" ] || continue GL3D_LINK_FLAGS="${GL3D_LINK_FLAGS} -Wl,--wrap=${gl1_sym}" done < "${GL1_DIR}/wrapped_symbols.txt" fi # Multi-threaded CPU raytracer (mainline threading restored): link the main-thread # nanosleep->Asyncify-yield shim so the raw-thread raytracer joins (sleep_for busy-wait) # yield to the JS event loop instead of deadlocking on-demand pthread-Worker creation. # Mirrors the wasm/gl1 pattern (compile to .o, add to the link). Shim: # wasm/shims/nanosleep_yield.c; its EM_ASYNC_JS yield is covered by env.__asyncjs__* in # scripts/common/asyncify-imports.txt. emcc -c -pthread "${PROJECT_ROOT}/wasm/shims/nanosleep_yield.c" -o "${STUBS_BUILD}/nanosleep_yield.o" NANOSLEEP_YIELD_LINK="${STUBS_BUILD}/nanosleep_yield.o" # mallinfo() stub for the mimalloc build: -sMALLOC=mimalloc doesn't export the # glibc mallinfo() that OpenCASCADE's OSD_MemInfo.cxx (libTKernel, pcbnew's 3D) # references — without this the pcbnew link fails `undefined symbol: mallinfo`. # Zeroed no-op (memory reporting only); harmless for apps that don't reference it. emcc -c "${PROJECT_ROOT}/wasm/shims/mallinfo_stub.c" -o "${STUBS_BUILD}/mallinfo_stub.o" MALLINFO_STUB_LINK="${STUBS_BUILD}/mallinfo_stub.o" # Pre-warmed Web Worker pool size (emscripten pthreads). The 3D-viewer CPU raytracer runs # KiCad's shared thread pool (hardware_concurrency long-lived threads, created at startup) # AND, for camera-move preview + post-process passes, spawns its OWN set of raw std::thread # workers — so a 3D-viewer session needs ~2x hardware_concurrency Workers *simultaneously*. # With only one set pre-warmed, the raytracer's threads fall back to on-demand `new Worker()`, # whose loaded→run handshake needs the main thread back in the JS event loop — which it can't # reach while blocked in the render's busy-wait join (no PROXY_TO_PTHREAD; the join runs on the # browser main thread). That circular wait is the 3D-viewer deadlock: moving the model, dragging # or resizing the viewer all freeze the tab. Pre-warm enough Workers that on-demand creation # never happens. Only 3D-viewer builds pay the extra startup Workers; other apps keep one set. if [ "${BUILD_3D_VIEWER:-OFF}" = "ON" ]; then PTHREAD_POOL_EXPR='navigator.hardwareConcurrency*2+8' else PTHREAD_POOL_EXPR='navigator.hardwareConcurrency' fi emcmake cmake "${KICAD_DIR}" \ ${CCACHE_OPTS} \ ${SYM_CONVERTER_CMAKE_FLAG} \ ${MERGED_EDITOR_CMAKE_FLAG} \ ${OCC_SERVICE_CMAKE_FLAG} \ -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \ -DCMAKE_INSTALL_PREFIX="${SYSROOT}" \ -DCMAKE_MODULE_PATH="${WASM_LAYER}/cmake" \ -DSYSROOT="${SYSROOT}" \ -DCMAKE_POLICY_VERSION_MINIMUM=3.5 \ -DCMAKE_CXX_FLAGS="${EXTRA_FLAGS} -Xclang -fno-pch-timestamp -pthread -sUSE_ZLIB=1 -DKICAD_USE_PLATFORM_WASM=1${DIAG_DEFINES} -I${SYSROOT}/include -I${STUBS_DIR} -include ${STUBS_DIR}/char_traits_uint16_workaround.h" \ -DCMAKE_C_FLAGS="${EXTRA_FLAGS} -pthread -sUSE_ZLIB=1 -I${SYSROOT}/include -I${STUBS_DIR}" \ -DCMAKE_EXE_LINKER_FLAGS="${LINKER_DEBUG_FLAGS} -pthread -sUSE_ZLIB=1 -sASYNCIFY=1 -sDYNCALLS=1 -sASYNCIFY_STACK_SIZE=65536 -sUSE_PTHREADS=1 -sMALLOC=mimalloc -sPTHREAD_POOL_SIZE='${PTHREAD_POOL_EXPR}' -sPTHREAD_POOL_SIZE_STRICT=0 -sALLOW_MEMORY_GROWTH=1 -sINITIAL_MEMORY=256MB -sMAXIMUM_MEMORY=4GB -sMAX_WEBGL_VERSION=2 ${GL3D_LINK_FLAGS} ${NANOSLEEP_YIELD_LINK} ${MALLINFO_STUB_LINK} -sEXPORTED_RUNTIME_METHODS=['ccall','cwrap','UTF8ToString','stringToUTF8','lengthBytesUTF8','dynCall'] -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE=['\$dynCall'] --bind -L${SYSROOT}/lib ${STUBS_BUILD}/libgit2_stub.a ${STUBS_BUILD}/libcurl_stub.a${APP_STUB_LINK} ${STUBS_BUILD}/libnng_stub.a ${EMBIND_OBJ}" \ -DCMAKE_PREFIX_PATH="${SYSROOT};${WX_BUILD}" \ -DwxWidgets_CONFIG_EXECUTABLE="${WX_BUILD}/wx-config" \ \ -DKICAD_BUILD_QA_TESTS=OFF \ -DKICAD_SPICE=OFF \ -DKICAD_USE_EGL=OFF \ -DKICAD_USE_BUNDLED_GLEW=ON \ -DKICAD_BUILD_3D_VIEWER_WASM=${BUILD_3D_VIEWER} \ -DKICAD_IPC_API=ON \ -DKICAD_USE_PCH=ON \ \ -DZSTD_ROOT="${SYSROOT}" \ -DZSTD_INCLUDE_DIR="${SYSROOT}/include" \ -DZSTD_LIBRARY="${SYSROOT}/lib/libzstd.a" \ -DGLM_INCLUDE_DIR="${SYSROOT}/include" \ -DGLM_VERSION="0.9.9.8" \ -DBOOST_ROOT="${SYSROOT}" \ -DBoost_INCLUDE_DIR="${SYSROOT}/include" \ -DBoost_LIBRARY_DIR="${SYSROOT}/lib" \ -DBoost_NO_SYSTEM_PATHS=ON \ -DBoost_NO_BOOST_CMAKE=ON \ -DFREETYPE_INCLUDE_DIR_ft2build="${SYSROOT}/include/freetype2" \ -DFREETYPE_INCLUDE_DIR_freetype2="${SYSROOT}/include/freetype2" \ -DFREETYPE_LIBRARY="${SYSROOT}/lib/libfreetype.a" \ -DHarfBuzz_INCLUDE_DIR="${SYSROOT}/include/harfbuzz" \ -DHarfBuzz_LIBRARY="${SYSROOT}/lib/libharfbuzz.a" \ -DOCC_INCLUDE_DIR="${SYSROOT}/include/opencascade" \ -DOCC_LIBRARY_DIR="${SYSROOT}/lib" \ -DProtobuf_INCLUDE_DIR="${SYSROOT}/include" \ -DProtobuf_LIBRARY="${SYSROOT}/lib/libprotobuf.a" \ -DProtobuf_LITE_LIBRARY="${SYSROOT}/lib/libprotobuf-lite.a" \ -DProtobuf_PROTOC_EXECUTABLE="${SYSROOT}/bin/protoc" \ -DODBC_CONFIG:STRING="stub-for-wasm" \ -DODBCLIB:STRING="" \ -DODBC_CFLAGS:STRING="" \ -DODBC_LINK_FLAGS:STRING="" \ -DODBC_LIBRARIES:STRING="" \ \ -DHAVE_STRCASECMP=1 \ -DHAVE_STRNCASECMP=1 # Step 7.1: Compile Embind bindings (after CMake so config.h exists) # Exposes KiCad objects to JavaScript for future Pyodide integration. # When no app-specific source exists, build an empty object so the linker line # referencing ${APP_NAME}_embind.o doesn't break. # Compile one embind TU with the same includes and ABI-critical flags KiCad uses # (KICAD_TU_ABI_FLAGS must match the core's -DDEBUG state or vtable dispatch skews — # task #54). Args:

[extra-defines] compile_embind_tu() { local _src="$1" _obj="$2" _subdir="$3" _defines="${4:-}" local _includes="-I${KICAD_BUILD} -I${KICAD_DIR}/include -I${KICAD_DIR}/${_subdir} -I${KICAD_DIR}/common" # Generated DSN-lexer headers (e.g. pcb_lexer.h, used transitively via kicad_clipboard.h → # pcb_io_kicad_sexpr_parser.h) are emitted into the common build subdir by make_lexer. _includes+=" -I${KICAD_BUILD}/common" _includes+=" -I${KICAD_DIR}/libs/core/include -I${KICAD_DIR}/libs/kimath/include -I${KICAD_DIR}/libs/kiplatform/include" _includes+=" -I${KICAD_DIR}/thirdparty/clipper2/Clipper2Lib/include" _includes+=" -I${KICAD_DIR}/thirdparty/nlohmann_json" _includes+=" -I${KICAD_DIR}/thirdparty/expected/include" _includes+=" -I${KICAD_DIR}/thirdparty/rtree" _includes+=" -I${KICAD_DIR}/thirdparty/fmt" _includes+=" -I${KICAD_DIR}/thirdparty/dynamic_bitset" _includes+=" -I${KICAD_DIR}/thirdparty/nanodbc" _includes+=" -I${KICAD_DIR}/thirdparty/picosha2" _includes+=" -I${KICAD_DIR}/thirdparty" # libcontext.h lives one level deeper; tool/coroutine.h does #include _includes+=" -I${KICAD_DIR}/thirdparty/libcontext" _includes+=" -I${SYSROOT}/include" # KiCad requires C++20 for concepts em++ -std=c++20 -c ${EXTRA_FLAGS} ${KICAD_TU_ABI_FLAGS} ${WX_CXXFLAGS} ${_defines} ${_includes} "${_src}" -o "${_obj}" } if [ "${APP_NAME}" = "kicad_editor" ]; then # Merged image: both per-editor TUs (with -DKICAD_MERGED_EMBIND compiling out # their duplicate definitions / shared-name registrations) + the dispatcher TU # registering the shared JS names once (wasm/bindings/kicad_editor_embind.cpp). # pcbnew's TU needs the generated lexer headers — pre-build pcbcommon (no wasted # work: kicad_editor depends on pcbcommon anyway; incremental no-op). log_info "Pre-building pcbcommon so generated lexer headers exist for the embind compile..." emmake make -j${JOBS} pcbcommon log_info "Compiling merged Embind bindings (pcbnew + eeschema + dispatcher)..." compile_embind_tu "${PROJECT_ROOT}/wasm/bindings/pcbnew_embind.cpp" \ "${STUBS_BUILD}/pcbnew_embind.o" pcbnew "-DKICAD_MERGED_EMBIND" compile_embind_tu "${PROJECT_ROOT}/wasm/bindings/eeschema_embind.cpp" \ "${STUBS_BUILD}/eeschema_embind.o" eeschema "-DKICAD_MERGED_EMBIND" compile_embind_tu "${PROJECT_ROOT}/wasm/bindings/kicad_editor_embind.cpp" \ "${STUBS_BUILD}/kicad_editor_embind.o" common elif [ -f "${EMBIND_SRC}" ]; then # pcbnew's embind TU transitively includes generated lexer headers # (kicad_clipboard.h → pcb_io_kicad_sexpr_parser.h → pcb_lexer.h, emitted into # ${KICAD_BUILD}/common by make_lexer custom commands on the pcbcommon target). # On a fresh build dir they don't exist until make runs — build pcbcommon first. # No wasted work: the app target depends on pcbcommon anyway; incremental no-op. # Guard on EMBIND_APP (not APP_NAME) so any app whose embind IS pcbnew's also # pre-builds pcbcommon. if [ "${EMBIND_APP}" = "pcbnew" ]; then log_info "Pre-building pcbcommon so generated lexer headers exist for the embind compile..." emmake make -j${JOBS} pcbcommon fi log_info "Compiling Embind bindings (${APP_NAME})..." # The include home is the app the BINDINGS belong to, not the artifact # subdir — for occ_service the two differ (bindings = pcbnew's; artifacts # land in the wasm/occ-service target's own occ_service/ binary dir, which # has no KiCad sources). case "${EMBIND_APP}" in pcbnew) EMBIND_INC_SUBDIR="pcbnew" ;; eeschema) EMBIND_INC_SUBDIR="eeschema" ;; *) EMBIND_INC_SUBDIR="${KICAD_SUBDIR}" ;; esac compile_embind_tu "${EMBIND_SRC}" "${EMBIND_OBJ}" "${EMBIND_INC_SUBDIR}" else log_info "No embind source for ${APP_NAME} (expected at ${EMBIND_SRC}); using empty placeholder" EMPTY_C="${STUBS_BUILD}/${APP_NAME}_embind_empty.c" : > "${EMPTY_C}" emcc -c "${EMPTY_C}" -o "${EMBIND_OBJ}" fi # Step 8: Build the app target kw_stage kicad-compile log_info "Building ${APP_NAME} (CMake target: ${KICAD_TARGET})..." # The embind object (step 7.1) is injected via linker flags, NOT tracked as a CMake/ # make dependency — so when ONLY _embind.cpp changes, make sees no changed source, # skips the link, and the new bindings silently vanish from the binary. Force a relink # whenever the freshly-compiled embind object is newer than the linked output. LINK_OUT_JS="${KICAD_BUILD}/${KICAD_SUBDIR}/${APP_NAME}.js" LINK_OUT_WASM="${KICAD_BUILD}/${KICAD_SUBDIR}/${APP_NAME}.wasm" # EMBIND_OBJ may hold several objects (kicad_editor) — check each. for _embind_obj in ${EMBIND_OBJ}; do if [ -f "${_embind_obj}" ] && [ -f "${LINK_OUT_JS}" ] && [ "${_embind_obj}" -nt "${LINK_OUT_JS}" ]; then log_info "Embind object newer than ${APP_NAME}.js — forcing relink to pick up new bindings" rm -f "${LINK_OUT_JS}" "${LINK_OUT_WASM}" break fi done emmake make -j${JOBS} "${KICAD_TARGET}" # Step 8.1: Build bitmap resources (images.tar.gz) # This creates the icon archive that KiCad loads at runtime. The headless # converter/service targets have no GUI/icons, so skip it. if [ "${APP_NAME}" != "sym_convert" ] && [ "${APP_NAME}" != "occ_service" ]; then kw_stage kicad-bitmaps log_info "Building bitmap resources..." emmake make bitmap_archive_build fi # Step 9: Create stamp file create_stamp "${KICAD_STAMP}" log_info "KiCad ${APP_NAME} build complete!" log_info "Output: ${KICAD_BUILD}/${KICAD_SUBDIR}/${APP_NAME}.js"