PicoForge is a modern desktop application for configuring and managing Pico FIDO security keys. Built with Rust, Tauri, and Svelte, it provides an intuitive interface for:

Reading device information and firmware details
Configuring USB VID/PID and product names
Adjusting LED settings (GPIO, brightness, driver)
Managing security features (secure boot, firmware locking)
Real-time system logging and diagnostics
Support for multiple hardware variants and vendors

Alpha Status: This application is currently under active development and in alpha stage. Users should expect bugs and are encouraged to report them. The app has been tested on Linux with the official Raspberry Pi Pico2 and currently supports Pico FIDO firmware version 7.2 only. Release binaries will be built and published soon.

Screenshots

Main Interface

Configuration Panel

Features

Device Configuration - Customize USB identifiers, LED behavior, and hardware settings
Security Management - Enable secure boot and firmware verification (experimental)
Real-time Monitoring - View flash usage, connection status, and system logs
Modern UI - Clean, responsive interface built with Svelte and shadcn-svelte
Multi-Vendor Support - Preset configurations for YubiKey, Nitrokey, SoloKeys, and more
Cross-Platform - Works on Windows, macOS, and Linux

Requirements

Runtime Requirements

Smart Card Reader (PC/SC compatible)
Pico FIDO device in Rescue mode

Development Requirements

To contribute to PicoForge, you'll need:

Deno - JavaScript/TypeScript runtime
Rust - System programming language (1.70+)
PC/SC Middleware:
- Linux: pcscd (usually pre-installed)
- macOS: Built-in
- Windows: Built-in

Building from Source

1. Clone the Repository

git clone https://github.com/librekeys/picoforge.git
cd picoforge

2. Install Dependencies

deno install

3. Build the Application

Development Build

deno task tauri dev

Production Build

deno task tauri build

The compiled binaries will be available in:

Linux: src-tauri/target/release/bundle/
macOS: src-tauri/target/release/bundle/dmg/
Windows: src-tauri/target/release/bundle/

Platform-Specific Notes

Linux

Install PC/SC dependencies:

sudo apt install libpcsclite-dev pcscd

Start the PC/SC daemon:

sudo systemctl start pcscd
sudo systemctl enable pcscd

macOS

No additional setup required. PC/SC framework is built-in.

Windows

Ensure Smart Card service is running:

Get-Service SCardSvr | Start-Service

Usage

Connect your smart card reader
Insert your Pico FIDO device (in Rescue mode)
Launch PicoForge
Click Connect Device to detect your key
Navigate through the sidebar to configure settings:
- Home - Device overview and quick actions
- Configuration - USB settings, LED options
- Security - Secure boot management (experimental)
- Logs - Real-time event monitoring
- About - Application information

Configuration Options

USB Identity

VID/PID - Vendor and Product IDs (hex format)
Product Name - Device name shown to host system
Vendor Presets - Quick selection for common manufacturers

LED Settings

GPIO Pin - Hardware pin for LED control
Brightness - Intensity level (0-15)
Driver Type - Hardware-specific LED drivers
Options - Dimmable, steady mode, power cycle behavior

Advanced

Touch Timeout - User presence button timeout (seconds)
Secp256k1 - Enable secp256k1 curve support
Secure Boot - Firmware signature verification (⚠️ experimental)

Project Structure

picoforge/
├── src/                      # Svelte frontend
│   ├── lib/                  # Reusable components & utilities
│   ├── routes/               # SvelteKit pages
│   ├── app.css               # Global styles
│   └── app.html              # HTML template
├── src-tauri/                # Rust backend
│   ├── src/                  # Rust source code
│   │   └── lib.rs            # Tauri commands & PC/SC logic
│   ├── icons/                # Application icons
│   ├── capabilities/         # Tauri permissions
│   ├── Cargo.toml            # Rust dependencies
│   ├── tauri.conf.json       # Tauri configuration
│   └── build.rs              # Build script
├── static/                   # Static assets
│   ├── build-configure-symbolic.svg
│   └── favicon.png
├── node_modules/             # Deno node compatibility modules
├── components.json           # shadcn-svelte config
├── package.json              # Node package manifest
├── deno.lock                 # Deno lock file
├── svelte.config.js          # SvelteKit configuration
├── vite.config.js            # Vite bundler config
├── tsconfig.json             # TypeScript configuration
└── LICENSE                   # AGPL-3.0 license

Contributing

Contributions are welcome! Please follow these steps:

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Development Guidelines

Follow Rust and TypeScript best practices
Write clear commit messages
Update documentation for new features
Test on multiple platforms when possible

License

This project is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0-only).

See LICENSE for full details.

Maintainers

Suyog Tandel (@lockedmutex)

Acknowledgments

Pico FIDO - The firmware this tool configures
Tauri - Desktop application framework
Svelte - Reactive UI framework
shadcn-svelte - UI component library
pcsc-rust - Smart card interface

Support

Discord: Join our Discord server for community support and interaction
Issues: GitHub Issues
Discussions: GitHub Discussions

Disclaimer

PicoForge is experimental software. The secure boot feature can permanently lock devices if misconfigured. Always understand the implications before enabling security features.

Made by the LibreKeys community