Kern is one of the more interesting DIY Bitcoin hardware signer projects I have been watching recently. It is built around ESP32-P4 boards, and it can run on smaller development displays as well as larger touchscreen panels such as the 10.1-inch tablet shown in this video.
If you want to see the full walkthrough, Watch the video. This article is a standalone written version of that preview, so it should still be useful if you prefer reading or if the video becomes unavailable later.
The short version: Kern is already capable enough for experimentation and development use, but it is still a work in progress. If you are comfortable with DIY Bitcoin tools, this is worth watching closely. If you plan to store large amounts of funds, I would be cautious until the project has had more time to stabilise.
Build your own hardware wallet
Kits, smartcard hats, cases and parts for SeedSigner, ShieldSigner, Specter DIY and Satochip builds, tested with the firmware shown in these videos and shipped from Canada.
What Kern Is
Kern is an experimental ESP32-P4 air-gapped Bitcoin signer project. It supports common BIP39/BIP32-style workflows that DIY Bitcoin users will already recognise from projects like KruX, Specter DIY, and other seed signers.
In the video, I test it on two types of hardware:
- A smaller Waveshare ESP32-P4 board with a 4.3-inch display.
- A larger Elecrow CrowPanel 10.1-inch tablet-style ESP32-P4 device.
The bigger screen is not for everyone. But for a signer, it can be surprisingly useful because you can see QR codes, address details, transaction outputs, and signing prompts more easily than on a tiny display.
Kern is still evolving quickly. That means the project has some rough edges, but it also already supports a lot of core functionality:
- Mnemonic creation from camera input.
- Loading existing mnemonics.
- Exporting extended public keys.
- Address verification.
- Signing PSBTs.
- Storing descriptors on device flash or microSD.
- Single-signature workflows in Sparrow.
- Standard multisig workflows in Sparrow.
- Miniscript/decaying multisig workflows with Liana.
The important thing to keep in mind is that this is not a polished retail product yet. It is a DIY project, and you should treat it like one.
Quick Start With the Web Flasher
One of the best parts of Kern for beginners is how quickly you can get something running without installing a full development environment first.
The official GitHub repository includes a web flasher. This lets you flash development firmware from your browser once the board is connected correctly over USB.

Here is the basic process I used on the Waveshare ESP32-P4 4.3-inch board:
- Install the camera by sliding it into its connector and clicking the retaining lever down.
- Connect the board to your computer using the correct USB port, usually the USB-to-UART port.
- Open the Kern web flasher in your browser.
- Click connect. If no device appears, try the other USB port.
- Select the matching ESP32-P4 target for your board.
- Flash the firmware.
- Press reset on the board after flashing.
If you selected the right target and flashed successfully, the device should boot into Kern instead of the stock app.

This is a great way to get an early win when starting with DIY hardware wallets. It removes a lot of setup friction before you decide whether you want to go deeper into local development.
But there is an important security caveat: the web flasher is used for development builds. These are not verified in the same way as release firmware or secure-boot-protected firmware would be. For testing, that is fine. For serious fund storage, you need to think carefully about what you are trusting and how you verify it.
Using Cloud AI Tools for Proof-of-Concept Firmware Changes
One of the most interesting parts of this video was using cloud-based AI tools to make a small firmware change without installing development tools locally.
I forked the repository, used GitHub Copilot or a similar tool, and asked it to change the default colour scheme from orange and black to light blue and black. The tool created a pull request, CI checks ran, and the modified firmware was built automatically. I then downloaded the resulting ZIP bundle and flashed it using the web flasher’s custom ZIP option.

This is not just a toy example. It shows how much easier it has become to test whether a project can run on new hardware, especially when that hardware is not officially supported yet.
I was able to get a working proof of concept running on the CrowPanel 10.1-inch device in under a day without installing a full local development environment. That is impressive.
However, I would still be very careful here. If you are using AI tools to modify firmware for a wallet that holds meaningful funds, do not blindly trust the output. You need to review the source code, understand what changed, and test carefully. Vibe-coded firmware fixes can be brilliant for prototyping, but they are risky if your real Bitcoin is on the line.
For development, testing, and hardware bring-up, this workflow is excellent. For production use with large balances, I would not rely on it without a much higher level of review.
Single-Signature Use in Sparrow
Once Kern is running, the basic single-signature workflow is very familiar if you have used other DIY seed signers.
In the video, I created a new mnemonic from camera input. The device can generate entropy from the camera and give you a 12-word mnemonic to back up. You should always write down your backup properly. Never store your only copy on the device itself.
After loading or creating a mnemonic, Kern can export an extended public key, or xpub. I imported that into Sparrow as an air-gapped hardware wallet keystore and selected a KruX-compatible option because much of this ecosystem is compatible with those workflows.

From there, the normal flow works:
- Receive an address in Sparrow.
- Verify that the same address appears on Kern.
- Send some Bitcoin to the address.
- Create a transaction in Sparrow.
- Finalise it for signing.
- Show the PSBT as a QR code.
- Scan the PSBT into Kern.
- Sign it.
- Return the signed PSBT to Sparrow by QR.
- Broadcast the transaction.
Kern also makes address verification easy. In the video, I scanned an address from Sparrow and confirmed on the device that it was address number two in the loaded seed. That is a useful security check before sending funds.

The large display helps here. You can see QR codes and transaction details without squinting or moving the device around too much. For signing, that is a real advantage over very small screens.
PIN, Anti-Phishing Words, and Wipe Threshold
Kern also includes some security settings that are worth understanding carefully.
You can set things like:
- A BIP39 passphrase.
- Screen brightness.
- Session timeout.
- A device wipe threshold.
- PIN-based protection.
- Anti-phishing words tied to the PIN.
The anti-phishing option is interesting because it can burn a cryptographic key into an eFuse on the ESP32-P4 board. That gives stronger hardware-backed protection, but it is irreversible.

In the video, I did not enable the irreversible part because I wanted to keep the device flexible. You can still set a PIN without enabling the full anti-phishing protection. If you do not enable it, you will get PIN protection but not the additional hardware-backed anti-phishing words.
This is one of those areas where you need to be deliberate. Once an eFuse is burned, you cannot undo it. I would only do that once you are confident in the firmware, your backup strategy, and the fact that you understand what you are locking down.
Standard Multisig With Sparrow
Kern also works with standard multisig setups. In the video, I loaded a descriptor into Kern from QR code, saved it to the device flash, and then used it to verify addresses in Sparrow.
This is one of the more useful security features for DIY multisig users: you can store encrypted descriptors on your hardware signer. That can improve setup security because the signing device knows the expected wallet structure locally.
The basic flow was:
- Create or load a multisig descriptor in Sparrow.
- Scan that descriptor into Kern.
- Save it to device flash, optionally encrypted.
- Use Kern to verify addresses generated by Sparrow.
- Sign transactions as normal using the multisig workflow.
This is still development firmware, so I would not rush to put serious funds through this without testing carefully. But the fact that descriptor storage and verification are available on a DIY signer is genuinely useful.
Miniscript and Decaying Multisig With Liana
The video also covers miniscript workflows using Liana. This is where things get more advanced, but it is one of the reasons Kern is interesting: it is not just another basic single-signature device. It can be used with more complex wallet structures.
For the demo, I created a simple inheritance-style multisig wallet in Liana and used Kern as the primary key source. The first step was exporting an xpub file to microSD so Liana could import it.
That part worked well. I inserted a microSD card, saved the extended public key file from Kern, and imported it into Liana.
The trickier part was loading the multisig descriptor back onto Kern. Liana’s default binary descriptor file was not found by Kern in this test. The workaround was to use a text version of the descriptor and place it in the correct folder on the microSD card.

This is where DIY projects can be frustrating. The location of files on the microSD card matters, and if a file format or path is not supported yet, you may need to adapt manually.
Once the descriptor was in the right place, Kern could load it. I then saved that descriptor to device flash as well. After that, Liana address verification worked, and I was able to sign a PSBT from Liana using Kern.
There was one issue with saving the signed PSBT to microSD. In this case, I used DeepSeek to help investigate the error, pushed a test fix, built the firmware, flashed it through the web flasher, and then confirmed that signing and saving worked.
Again, this is where I would be very careful if you are using real funds. AI-assisted debugging can be extremely helpful for finding bugs quickly, but you should not casually run unreviewed modified firmware on a wallet holding meaningful Bitcoin. For prototyping, it is powerful. For production security, review everything.
Why Secure Boot Is Probably Not a Good Idea Yet
The ESP32-P4 supports secure boot and flash encryption at the hardware level. That sounds good, but in this stage of the project, I would probably avoid locking down your device with secure boot.
The reason is simple: the firmware is still changing. If you enable secure boot now, you may make recovery or future updates much harder if something goes wrong. Without secure boot, you can usually put the board back into flash mode and reflash it. That gives you a lot more flexibility while the project matures.
There is another issue: at this stage, the current firmware does not support updating from microSD in the way you might want for a locked-down device. If you lock the device all the way down, you may also limit your ability to update beyond what was initially flashed.
So my advice would be: wait on secure boot unless you are fully comfortable with the exact firmware state, understand the trade-offs, and do not mind replacing the board later if needed.
For now, flexibility is more valuable than a locked-down device that might become hard to recover.
CrowPanel 10.1 Case and Hardware Notes
The larger CrowPanel 10.1-inch device is interesting because it gives you a much bigger touchscreen in a tablet-like form factor. In the video, I used a simple case designed for this board. The case keeps the important inputs accessible while giving the device something more solid to hold.
If you want to make your own case, the Kern repository includes enclosure files under the CrowPanel 10.1 section, including STLs and a FreeCAD design file.
One thing worth noting: some ESP32-P4 boards include Wi-Fi and Bluetooth hardware. In the firmware shown here, those features are disabled. But for some users, disabling them in software is not enough. If you want to physically disable wireless hardware, that is another DIY consideration. Documentation around which boards make that easier has not been fully written up yet.
If paranoia about wireless hardware matters to you, this is something to research before choosing a board.
Local ESP-IDF Build and Flash on Windows
The final part of the video covers building Kern locally using ESP-IDF. This is useful if you want to verify firmware yourself instead of relying only on cloud builds or official release artifacts. It is also useful if you are making your own changes.
On Windows, I used the graphical ESP-IDF installer rather than trying to set everything up manually from scratch. Once installed, I opened the IDF terminal and cloned the Kern repository.
The general process was:
- Install ESP-IDF using the graphical installer for Windows.
- Open the IDF terminal.
- Clone the Kern repository.
- Change directory into the project folder.
- Run the build/flash command for your target board.
- If Python 3 is not detected, apply the workaround described below.
During the build, I hit a Windows-specific issue where CMake could not find python3. This is a known annoyance in some ESP-IDF setups on Windows. The simple fix was to go into the Espressif tools directory, find the Python scripts folder, make a copy of Python, and name it Python 3. After doing that, the build and flash command worked.

Once your local build environment is working, you can modify the codebase, rebuild, and reflash using the same process. That gives you much more control over what ends up on your device.
Is Kern Ready for Real Funds?
Kern is close to being useful for real-world use, but I would still call it a work in progress. The core functionality is there, and in some ways it already feels more capable than some retail hardware wallets. But the project is still moving quickly, documentation is limited, and some workflows need more polish.
The biggest advantage right now is standards compatibility. If you create a wallet in Kern and later run into problems, you can usually take your seed phrase or descriptor to another compatible signer, whether DIY or retail. That makes it much less of a dead end than a proprietary device that only works with one ecosystem.
That said, if you are not comfortable being on the bleeding edge, I would not rush in with large funds. There is still roughness around the edges:
- Development firmware needs careful verification.
- Secure boot should probably wait until things stabilise more.
- microSD handling can have quirks.
- Some documentation and guides are missing.
- Wireless hardware considerations may matter to some users.
- AI-assisted fixes can be useful, but they need review before production use.
For people who enjoy DIY Bitcoin, this is a very exciting project. For people who want something simple, polished, and fully documented, it may not be the right choice yet.
Final Thoughts
Kern is one of the more promising ESP32-P4-based DIY signers I have seen. The web flasher makes it easy to get started quickly, the large tablet display is genuinely useful for QR workflows, and support for single-sig, multisig, and miniscript-style wallets makes it much more than a basic signer.
If you are experimenting with DIY Bitcoin hardware, this is worth testing. If you want to use cloud AI tools to bring Kern onto new boards or test modifications, the project is flexible enough to make that practical. But if you plan to store meaningful funds, I would move slowly: back up properly, verify what you flash, avoid irreversible eFuse changes until you are confident, and keep a compatible fallback path in mind.
This is not yet “set it and forget it” territory. It is early-stage DIY hardware with serious potential. If you are comfortable with that, Kern is definitely one to watch.
Build your own hardware wallet
Kits, smartcard hats, cases and parts for SeedSigner, ShieldSigner, Specter DIY and Satochip builds, tested with the firmware shown in these videos and shipped from Canada.
Found this useful?
These guides are free and ad-free. You can support them by sharing them, subscribing on YouTube, or sending a tip.







