, ,

DIY Hardware Wallets: Private, Trustless, Educational

A hardware wallet is one of the fastest ways to make your self-custody setup stronger. But it does not have to mean “buy a retail device and trust the vendor completely.” If you want more privacy, less supply-chain trust, easier parts access, or just enjoy building things, DIY hardware wallets are worth looking at seriously.

The important thing is that DIY does not automatically mean safer. Some projects are very easy to use but have weaker firmware protection. Others are harder to build but can run official firmware and behave like retail devices. In this guide, I’ll walk through the main options I cover in Watch the video, what they are good for, where they fall short, and how to think about choosing one based on your skills, parts availability, and security goals.

Jade DIY hardware wallet showing unlocked home screen
A small ESP32-based Jade-style device after flashing

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.

Why build a hardware wallet yourself?

There are several practical reasons to consider a DIY self-custody device:

  • Privacy: You may not want to buy from a retailer that knows you are buying a Bitcoin or crypto wallet.
  • Reduced vendor trust: Building your own can reduce reliance on one company’s supply chain, firmware packaging, and support process.
  • Parts availability: In some regions, retail hardware wallets are hard to get, but generic components may be easier to source.
  • Education: Working through the build helps you understand what a device is doing, how it connects, and where trust assumptions matter.
  • Recovery or deniability: Some low-cost builds can be useful in constrained situations, though they should not be treated as high-security devices by default.

The best project depends on your comfort level. If you want something simple to start with, I would usually look at Jade-style ESP32 builds or Krux first. If you are comfortable soldering and want official firmware compatibility, KeepKey or Trezor One DIY projects may make more sense. If you want strong secure-element isolation in a small form factor, smartcard-based options like Satochip deserve attention.

Jade and Jade Plus: the easiest starting point

Jade and Jade Plus are among the most approachable DIY hardware wallet options because the hardware can be ready-made. In practice, this means you can use ESP32-based boards such as an M5 Stick C plus two for a normal Jade-style build, or a LilyGo T-Display S3 Pro for a Jade Plus-style build with a camera.

The main advantage is that there is no soldering and no complex assembly. You take the device out of the box and flash it.

Flashing Jade firmware from a browser

  1. Connect the ESP32-based device to your computer or phone over USB, depending on the setup you are using.
  2. Open the provided web-based flashing process in your browser.
  3. Follow the prompts to install the DIY firmware.
  4. Once flashed, use it with vendor-supported software and documentation as you would a retail Jade.

This is one of the biggest strengths of Jade for beginners: once the DIY firmware is installed, the device behaves much like a retail Jade. You can connect over USB or Bluetooth, use desktop or mobile software, and rely on existing Jade documentation.

Security caveats

The base browser-flashing process is convenient, but it is not the full security story. To get closer to the protection level of a properly locked-down retail Jade, you should look at advanced steps such as secure boot and flash encryption. If you skip those steps, you are getting an easy-to-use DIY device, but not necessarily the strongest possible version of that project.

I rate the hardware security of these devices as high if you complete the more advanced lockdown steps. The seed material on the device is encrypted, and Jade’s blind PIN server design is a clever protection mechanism for protecting against some forms of PIN brute-force attacks. But convenience and maximum security are not the same thing here.

KeepKey DIY: official firmware with more work

The DIY KeepKey project is interesting because it can run retail KeepKey firmware. That means you can use the official KeepKey app, update firmware through vendor software, and get a usage experience that feels familiar if you already know KeepKey.

The downside is assembly difficulty. This is not a press-fit beginner build. You need to work with a development board, solder wires, and put the hardware together carefully. Firmware setup is also less straightforward than Jade because you are dealing with building and flashing firmware rather than simply using a browser-based process.

What I like about this route

  • It can run official KeepKey firmware.
  • You can use vendor software for updates and normal operation.
  • The usage complexity, once built, is similar to a retail KeepKey.

Security notes

I rate the hardware security as medium. You can lock down the bootloader on these older devices, but key extraction attacks have been demonstrated against some older hardware designs. A DIY KeepKey would still be exposed to those kinds of concerns because it uses the same general class of hardware and firmware environment.

If you want a familiar interface and are comfortable doing real soldering work, this can be a good project. If you want the easiest possible entry point, I would not start here.

Krux on K210: easy to flash, more advanced to use

Krux is another strong DIY option because assembly is easy and setup has become much simpler with the Krux Installer. You can download and verify the installer from the Krux GitHub project, select your device model, and run verification plus flashing.

Krux Installer desktop window next to a USB-connected K210-based wallet
Flashing Krux firmware with the Krux Installer

Basic Krux setup flow

  1. Download the Krux Installer from the official GitHub project.
  2. Verify the installer and files you are using.
  3. Select your K210-based device model, such as Yarboom.
  4. Run verification and flashing through the installer.
  5. Optionally configure tamper-check features in the device settings.

Krux is more powerful than some simpler QR-only signers, but that power comes with complexity. I rate usage as advanced compared with USB wallets where you plug in and work immediately. Transactions are shared using camera or microSD workflows, which takes a little more thought.

Tamper check versus tamper protection

One important distinction: K210 devices do not have native bootloader lockdown the way some other hardware does. Krux compensates partly with features such as a tamper-check code and flash-hash checking at boot.

You can set a PIN-like tamper-check code, fill unused flash space with entropy from the camera, then enable flash-hash checking at boot. After that, if you unplug and reconnect the device, it can prompt for the code and show anti-tamper words or icons indicating whether the flash memory appears unchanged.

This is useful, but it is not the same thing as true hardware tamper protection. It is an easy way to add a check, not a guarantee that malicious modification is impossible.

piTrezor: cheap, simple, and low security

piTrezor is one of the cheapest options on this list. It can be built around a Raspberry Pi Zero or similar board with mostly press-fit components. I have used an original Raspberry Pi 1A in the past, but the general idea is the same: run piTrezor from an SD card and connect over USB.

Red piTrezor-style device showing a backup warning on OLED screen
piTrezor with OLED display and buttons

Basic piTrezor setup flow

  1. Source a Raspberry Pi Zero or compatible board.
  2. Add press-fit components such as an OLED, buttons, and USB connection.
  3. Optionally add a custom hat if you want a cleaner build.
  4. Flash the piTrezor image to an SD card.
  5. Connect the device over USB and use it with Trezor Suite.

The big caveat is hardware security. I rate it as low because the system runs from an SD card on a Raspberry Pi over USB. There is no strong secure element or locked-down bootloader in the way you would want for long-term high-value storage.

That said, piTrezor has real uses:

  • It is cheap and simple.
  • Parts are commonly available.
  • It can be useful in recovery situations where a normal Trezor is not accessible.
  • It offers excellent plausible deniability because the hardware looks like a generic Raspberry Pi project.

If you are trying to recover access to funds rather than build your first high-security device, this may not be the best long-term answer, but it can be a practical bridge in some cases. If that is your situation, I also cover recovery services and consultations for people who need help getting back into their wallets safely.

One important usability note: Trezor Suite may warn you that the device is unofficial or possibly tampered with. If you knowingly built piTrezor, you can disable the firmware authenticity check in Trezor Suite so it will work like a Trezor One from your perspective. But remember: convenience here does not equal high hardware security.

Satochip smartcard: small, isolated, and blind-signing focused

Satochip is a simple smartcard-based signer. There is no assembly because the device is effectively a JavaCard-style secure element. The main practical challenge is sourcing decent cards. You can get them from dedicated stores, including my store, but random marketplace listings may be hit or miss.

Sparrow wallet importing a Satochip and a smartcard in a USB reader
Using a Satochip with Sparrow via USB reader

Why people use Satochip

  • Very high hardware isolation because signing happens inside the secure element.
  • Small physical footprint.
  • Useful as part of multisig setups.
  • Good for smaller amounts or as one signer in a larger scheme.
  • Works nicely with wallets such as Sparrow.

The tradeoff is that it is a blind signer. It does not have a screen, so you are not reviewing full transaction details on the device itself. For large or complex transactions, that is a real limitation. If you need to inspect every input and output before signing, a display-based device may be safer for day-to-day use.

If you want a compact secure-element signer and understand blind-signing risks, Satochip is worth considering. You can also store cards safely in an RFID blocking sleeve if you are concerned about accidental NFC contact or casual scanning.

SeedSigner and smartcard forks: simple QR signer with firmware caveats

SeedSigner is a popular DIY option because it gives you an air-gapped, camera-based signing workflow without needing USB data connection during normal use. Assembly is generally manageable but not as effortless as a ready-made Jade device. You need to source the Raspberry Pi, display, buttons, camera, and other parts, then press-fit them together.

Assembled SeedSigner with display, buttons, and case
A DIY SeedSigner after assembly

Assembly notes

  1. Source a Raspberry Pi board, preferably with pin headers already fitted if you are not comfortable soldering.
  2. Add the display hat, camera, buttons, and other required components.
  3. Press-fit the boards together carefully.
  4. Flash the firmware image to your microSD card.
  5. Insert the SD card and boot the device.

A common beginner issue is buying a Raspberry Pi without pin headers soldered on. If you are not comfortable soldering, buy one that already has them or use a kit designed to avoid that problem.

Security and usability

I rate SeedSigner firmware protection as low. Even though it can operate in a stateless way, there is still no strong firmware protection built into the hardware itself. Because of that, you should verify and flash the firmware image immediately before using the device, especially if you plan to sign large or complex transactions.

Connectivity is QR-only, which makes SeedSigner very useful for smaller transactions but painful for large ones with many inputs and outputs. The interface is simpler than Krux, which is a plus for many users, but it is not as powerful.

I also maintain a smartcard-based fork of SeedSigner that adds the ability to store seeds on smartcards, with future signing-on-smartcard functionality in mind. If you want this route, I have kits and parts available, including a SeedSigner + Smartcard Kit, a Smartcard Hat for Raspberry Pi with USB-C Input power, and cases such as the 3D Printed Case for SeedSigner + Smartcard Hat or a 3D Printed Case for Stock SeedSigner.

If you are building the standard SeedSigner Plus, a SeedSigner+ Display Hat & USB-C Power + MicroSD Extender and a 3D Printed Case for Stock SeedSigner Plus can make the build much cleaner.

Specter DIY and Specter Shield: good connectivity with secure boot by default

Specter DIY and Specter Shield are strong options if you want a more capable air-gapped wallet with multiple connection methods. They come in variants depending on whether you want smartcard-based seed storage or not.

Assembly is similar to SeedSigner: mostly press-fit, plug-and-play components. Firmware flashing is also straightforward because you can drag and drop the firmware file onto the device like a USB stick.

What makes Specter useful

  • QR code connectivity for air-gapped workflows.
  • microSD-based options.
  • USB connection for compatible software such as Liana or Specter Desktop.
  • Secure boot enabled by default.
  • Optional smartcard-based secret storage on Shield variants.

I rate hardware security as high because the device is locked down with secure boot, and you can also store secrets on a smartcard where applicable. The interface is more complex than SeedSigner and somewhat similar in spirit to Krux: powerful, but not as immediately simple for beginners.

If you want a practical case and board setup, I carry options such as the Specter DIY Case, Specter Shield Case, Specter Shield Lite Case, Specter Shield Board, and Specter Shield Budget Edition.

Trezor One DIY: official firmware, but harder to build

The Trezor One DIY project is similar in spirit to the KeepKey DIY route. It requires soldering, so it falls into the hard category for assembly. The benefit is that you can install the stock bootloader and run official Trezor One firmware on your DIY device.

That matters because you can use Trezor Suite normally, including enabling firmware authenticity checks. Unlike piTrezor, a properly built Trezor One DIY running official firmware should not be treated as an unofficial device in the same way. You can even update firmware through Trezor Suite like a genuine retail device.

What to expect

  • More physical work than press-fit projects.
  • Official stock bootloader and firmware support.
  • Familiar use with Trezor Suite.
  • Medium hardware security, assuming you lock it down properly.
  • Long-term support depends on how long Trezor continues supporting the original Trezor One.

If you already trust the Trezor ecosystem and are comfortable soldering, this is a legitimate option. If you want the easiest path to official firmware compatibility, I would compare it against KeepKey DIY based on parts availability and your comfort with each project’s documentation.

Keyflint preview: interesting but still alpha

Keyflint is another project worth watching, but as of now I consider it more experimental than ready for most users. It runs largely on an Arduino-style ESP32 platform and can create seeds, add entropy, view addresses, and perform basic signing-related tasks.

The hardware panel itself may be straightforward to assemble, but compatible serial readers are harder to source, and the firmware needs to be built from source. There is also no proper low-profile case or refined reader workflow yet.

I rate its hardware security as low for this stage. Even though it uses an ESP32 board similar in class to Jade-style devices, the Arduino stack makes it less straightforward to lock down with secure boot and flash encryption. That means malicious firmware could be reflashed over the top without a typical user necessarily noticing.

For most people, I would treat Keyflint as a development or tinkering project rather than a primary self-custody device right now.

Status Keycard: smartcard signer with an interesting shell

Status Keycard is similar to Satochip in that it uses a smartcard-based secure element and operates as a blind signer. At the time of this video, it can be used with some Android-based Ethereum apps.

The more interesting part is the Keycard Shell project, which adds air-gapped functionality and later compatibility with wallets such as MetaMask, Blue Wallet, Sparrow, Specter, and others. The fact that both hardware and software information has been released on GitHub makes this worth watching closely.

If you are comfortable with blind signing and want a compact secure-element option, Status Keycard belongs in the same conversation as Satochip. If you need full transaction review on-device, it is not the right tool by itself.

How to choose the right DIY wallet

Here is how I would think about choosing:

Choose Jade or Jade Plus if:

  • You want the easiest start.
  • You do not want to solder.
  • You are comfortable with browser-based flashing.
  • You can follow advanced secure boot and flash encryption steps later.
  • You want a device that behaves like retail Jade software once flashed.

Choose Krux if:

  • You want an easy-to-flash, more powerful air-gapped signer.
  • You are okay with camera or microSD transaction workflows.
  • You understand that tamper-check features are not the same as native tamper protection.
  • You prefer a more advanced interface over maximum simplicity.

Choose piTrezor if:

  • Cost and parts availability matter more than high hardware security.
  • You need something simple for recovery, testing, or low-value use.
  • You understand it is not a strong long-term secure storage device.

Choose Satochip or Status Keycard if:

  • You want smartcard-level secure element isolation.
  • You are comfortable with blind signing.
  • You may be using multisig or smaller-amount spending setups.
  • You can source reliable cards and readers.

Choose SeedSigner if:

  • You want a simple QR-based air-gapped signer.
  • You are okay verifying firmware right before use.
  • You mostly sign smaller transactions rather than large complex ones.
  • You may want smartcard seed storage through the fork.

Choose Specter DIY or Specter Shield if:

  • You want strong connectivity options including QR, microSD, and USB.
  • You value secure boot enabled by default.
  • You are okay with a more capable but less beginner-simple interface.
  • You may want smartcard-based secret storage on Shield variants.

Choose KeepKey or Trezor One DIY if:

  • You are comfortable soldering.
  • You want official firmware compatibility.
  • You want to use vendor software such as KeepKey app or Trezor Suite.
  • You understand older hardware has known attack classes even when locked down.

Final thoughts

DIY hardware wallets are not for everyone, and they should not be treated as magic security upgrades. A retail device can be perfectly fine if you trust the vendor, verify firmware where possible, use strong PINs, back up your seed safely, and understand the threat model. But DIY projects are important because they give people options: better privacy, reduced supply-chain assumptions, access to parts in difficult regions, educational value, and sometimes a practical recovery path when normal hardware is unavailable.

The best choice depends on what you can build, what parts you can source, how much complexity you accept, and how much security you actually need for the amount of funds involved. If you are just starting out, begin with something like Jade or Krux before moving into soldering projects or blind signers. And whatever route you choose, verify firmware, keep your backups safe, and do not assume that a DIY label automatically means “more secure.”

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.

Stuck on this?

Book a one-hour session and I’ll walk you through it, or ask about a trusted recovery.

Recovery guides

More guides