quick navigation:

step one | step two | step three | step four | step five | step six | step seven | step eight | step nine | step ten | step eleven | step twelve | step thirteen | step fourteen

step one
install dependencies and build system

install all the necessary libraries and dependencies on the Linux host machine, then clone the Yocto build system (poky) via git. in termal, run the following commands:

for my distro and version of linux, i tried the kirkstone release first with no success and ended up using the scarthgap release.

step two
clone necessary layers and initialize build environment

inside the newly cloned poky directory, clone the raspberry pi USB layer and the open-embedded layer, necessary for libcamera and v4l-utils. run the commands:

next, initialize the build environment. still inside the poky directory, run:

this drops you into the new directory poky/build and generates the configuration files local.conf and bblayers.conf in the directory poky/build/conf

step three
bake the cloned layers and create a custom layer to bake

still inside poky/build, bake the layers we cloned. there is no confirmation message when adding the layers, so no message = all good! run:

create a custom layer to support wifi and camera inferfacing, as well as for any future customizations, and bake the custom layer. Yocto's built in tool for creating layers automatically creates the standard layer structure, with conf/layer.conf, recipes-example/, COPYING.MIT, and README. still in poky/build, run:

confirm all layers were added:

step four
add kernel configuration for wifi

create the configuration files for wifi capabilities in the custom layer. run:

step five
edit local configuration file

still in the poky/build directory, run:

find the line that says MACHINE and set the target machine:
MACHINE="raspberrypi0-wifi"

create a new line to set a limit on the maximum number of concurrent tasks that bitbake will execute. my system (2011 MacBook Air) failed at 4 and would only work with 2. if you're on a newer system, 4 may work, or you may not have to set a limit at all. 2 is the most conservative number of consecutive tasks, but i would say it's safe to set it at 4 and see if your machine can do that because it will take significantly less time. learning the right number for your machine is just trial and error; the worst thing it will do is fail and you'll have to come back to this step and adjust the number. after the line setting the target machine, add:
BB_NUMBER_THREADS="2"
PARALLEL_MAKE="-j 2"

enable UART / serial communication. at the bottom of the local.conf file, add:
ENABLE_UART="1"

enable I2C. under the line enabling UART, add:
ENABLE_I2C="1"

enable camera use. i used the raspberry pi camera module v3, IMX708 sensor, but the line can easily be changed to use the v2 IMX219 sensor. after the line to enable I2C, add:
RASPBERRYPI_CAMERA_V3="1"
or, if using v2:
RASPBERRYPI_CAMERA_V2="1"

add camera and wifi support modules and libraries. after the camera setting line, add:
IMAGE_INSTALL:append="linux-firmware-rpidistro-bcm43430 wpa-supplicant v4l-utils libcamera kernel-module-brcmfmac kernel-module-brcmfmac-wcc kernel-module-bcm2835-unicam i2c-tools imx708"
if using camera module v2, change "imx708" to "imx219".

add accepted flags and modules to force to autoload. after IMAGE_INSTALL, add lines:
LICENSE_FLAGS_ACCEPTED="synaptics-killswitch"
KERNEL_MODULE_AUTOLOAD+="brcmfmac bcm2835-unicam i2c-dev imx708"
again, if usng camera module v2, change "imx708" to "imx219".

step six
build the image!

we're ready to build the minimal image! inside the poky/build folder, run:

expect this to take a few hours on the first build. mine literally took about SEVEN hours. subsequent builds will take less time.

step seven
locate the image and decompress

the image will be a compressed file, the extension depending on how your machine compresses files, mine was .bz2. the image name will start with "core-image-minimal-raspberrypi0-wifi". my file name had the timestammp of the build at the end:
core-image-minimal-raspberrypi0-wifi.rootfs-20260803065926.wic.bz2

unzip the image using the found file name. run:

give it a minute to complete. the -k flag keeps the original zip file, copying it then unzipping the original. the -f flag ifnores that the file has a link to another file. the unzipped file extension will be .wic, which is the full disk image, including the blootloader, rootfs, and partition table. to see the file, run:

step eight
flash the microSD with your image!

locate the microSD. before and after inserting the card into the host machine, run the command:

bto be sure of the device name. verify that the size matches the microSD's size. DO NOT guess the device as you don't want to wipe your host machine!

mine appeared as /dev/sdc/ and a partition had a mount point because it was used before. if yours has a mount point, you'll need to unmount it first. to unmount, run:

replacing "sdc1" with what your device mount point is.

your microSD is ready to be flashed! run:

replace "sdc" with your block device name.

then eject safely. run:

then insert the microSD into the raspberry pi 0 w.

step nine
connect the USB to TTL adapter

in a minimal image, there is no HDMI friendly video output by default, and wifi won't be configured yet. we have to use serial to communicate with the pi, using a USB to TTL serial adapter.

connect the adapter to the pi's GPIO, only wiring GND, TX, and RX (see the pin out below, use UART0_TXD and UART0_RXD). use an external power supply to power the raspberry pi directly. i did it this way because eventually i need the pi to be independent, so i didn't want to rely on power from the adapter.

wire and plug the USB into the host computer. do NOT power the pi yet! there will be a specific instruction when the pi is ready to be plugged into power.

step ten
find device and set permissions

after adapter is inserted into host machine, run:

find a message that says new device connected and note the name. mine was "/dev/ttyUSB0/".

set up the serial terminal program and set permissions on the host machine. i used minicom for serial communication because i like the interface, but screen or picocom would be good alternatives as well.
install minicom and give yourself permission to communicate through serial. run:

then log out and log back in for the new permission to take effect.

step eleven
open serial communication

open terminal when logged back in. with the pi still NOT powered on, run:

replacing ttyUSB0 with your device name. finally, plug the power cable into the pi! after a moment, serial messages should stream in. wait for the login prompt, then type "root" and enter. if prompted for a password (i wasn't), just hit enter.

step twelve
confirm wifi driver

we are officially in the pi! let's confirm that the wifi driver is loaded properly. run:

the output should be a list with brcmfmac, brcmutil, cfg80211, and brcmfmac_wcc. then run:

the output should show wlan0 and lo.

step thirteen
make and initialize wpa_supplicant

create wpa_supplicant configuration file to connect to wifi. run:

replace "WIFI-NAME" and "WIFI-PASSWORD" with the name and password of the wifi you're connecting to. make sure the name exactly matches (capitalization, spaces, etc).

set up the interface and initialize wpa_supplicant. run:

step fourteen
IP address

ask the wifi router to assign an IP address to the pi. run:

after receiving a message that the pi obtained an IP address from the router's IP address, confirm / verify by running:

yay, the wifi is set up!