Introducing Biopass: Modern Multi-Modal Biometric Login for Linux

Nguyễn Phúc Vinh — Fri, 27 Feb 2026 09:32:30 +0000

If you use Linux on a modern laptop, you've probably envied the seamless Windows Hello experience—combining face, fingerprint, and PIN into one cohesive authentication system.

Historically, Linux has lacked a modern, unified equivalent. While the community has incredible tools like Howdy, it focuses exclusively on facial recognition, relies on CLI for management, and hasn't seen significant updates recently.

That's why @thaitran24 and I (@phucvinh57) decided to build Biopass: A fast, secure, and privacy-focused biometric authentication suite for Linux desktops supporting face, fingerprint, and eventually voice.

Why Biopass?

We wanted to build something that goes beyond simple facial recognition, providing a robust, multi-modal suite with a great user experience.

Here is how Biopass compares to existing solutions:

Multiple Modalities: Supports both Face and Fingerprint natively (with Voice on the roadmap).
Face Anti-Spoofing: Built-in liveness detection. You don't necessarily need an expensive IR camera for basic security against photo-spoofing.
Modern Interface: Say goodbye to terminal configurations. Biopass comes with a beautiful desktop GUI to manage your biometric settings.

Key Features

Flexible Authentication Setup: You can register multiple biometrics. Authentication can run in parallel (whichever recognizes you first wins) or sequentially.
Robust Face Auth: Combines recognition with advanced anti-spoofing.
Fingerprint Support: Seamless integration for quick OS-level unlocks.
Privacy First: Everything runs entirely locally on your machine.

Under the Hood: The Tech Stack

We built Biopass with performance and security in mind, splitting it into two primary layers:

1. The Core PAM Authentication Module (Backend)

The heavy lifting is done at the system level. When Linux requests authentication (e.g., login or sudo), the Linux Pluggable Authentication Module (PAM) steps in.

Language: C++17 for raw performance.
Machine Learning: LibTorch (PyTorch C++) powers local inference using YOLO (Face Detection), EdgeFace (Recognition), and MobileNetV3 (Anti-spoofing).
Vision: OpenCV handles image and frame processing.
Security Architecture: The PAM module spawns an isolated biopass-helper process to capture biometrics and perform inference, keeping the core OS auth flow stable and secure.

2. The Desktop Management App (Frontend)

Because it's 2026, you shouldn't have to edit YAML configs in vim just to enroll a fingerprint.

Framework: Tauri v2 + Rust creates a lightweight, secure bridge between the system calls and the UI.
UI: A blazing fast Vite + React frontend built with TypeScript and styled with TailwindCSS.

Installation and Setup

Getting started with Biopass is straightforward! We provide pre-built packages for easy installation.

Download the latest release: Visit our Releases page and download the appropriate package for your distribution (we provide .deb files for Debian/Ubuntu-based distros).
Install the package:

   sudo dpkg -i biopass_*.deb
   sudo apt-get install -f # to resolve any missing dependencies

Open the Biopass App: Launch Biopass from your application menu, set up your face or fingerprint data.
Enjoy seamless logins!

What's Next?

We are actively developing Biopass. On our immediate roadmap:

Voice Authentication: Recognition and anti-spoofing.
Local AI Model Management: Download, update, and manage your AI models right from the GUI.
Improve Face Anti-Spoofing: Current model is quite inaccurate.
IR Camera Support: Add support for IR cameras for better face recognition.

Try It Out & Get Involved

Biopass is fully open-source and we would absolutely love for the Linux community to try it out, report bugs, and contribute.

Repository: TickLabVN/biopass on GitHub
Download / Installation: Check out our Latest Release
Contributing: Want to help out? Check our Contributing Guidelines

Tonic - Swaggo alternative

Nguyễn Phúc Vinh — Sat, 17 Feb 2024 03:14:10 +0000

Introduction

My team just switched my main programming language from JavaScript to Go last month and tried to find an API docs library for our new project..

But frameworks like Gin or Echo do not support it natively like Fastify does. We found Swaggo, a wonderful tool, but it's required many steps: writing godocs, then use CLI to gen specs, and finally host swagger UI from specs. We just need a library that directly reflects my structs & routes definitions, then creates a Swagger UI for me, straightforwards and fully automatic.

Seems like the Go style is design-first approach, it's hard to find a library that meets our needs. So I created a Go lib, named Tonic, and want to share with community.

Visit my repo: https://github.com/TickLabVN/tonic

For the first release, Tonic may not support all features of OpenAPI and has some limitations. Welcome all contributions to make Tonic better.

Main ideas

Using the native lib reflect, Tonic reads struct's metadata like JSON tag, data type... and generates an object schema for the struct. For example:

type ArticleDTO struct {
    ID      int     `json:"id"`
    Title   string  `json:"title" binding:"required,min=4,max=255"`
    Content     string  `json:"content" binding:"required,min=20"`
}

// Will be generated to
{
    "id: {
        "type": "integer"
    },
    "title": {
        "type: "string",
        "minLength": 4,
        "maxLength": 255
    },
    "content": {
        "type: "string",
        "minLength": 20
    }
}

Route defintion in Tonic:

app := gin.Default()
rg := app.Group("/api")
tonic.CreateRoutes(rg.BasePath(), []tonic.Route{
    {
        Method: Tonic.Get,
        Url: "/ping",
        HandlerRegister: func(path) {
            rg.GET(path, Ping)
        },
        Schema: &tonic.RouteSchema{
            Response: map[int]interface{}{
                200: PingResponse{},
            }
        },
    }
})

After all, Tonic reads all route definitions and JSON schemas generated from structs, constructs all of these pieces of information into a Swagger object at runtime, then uses an external library to host the Swagger UI.

Tonic is not tightly coupled with any frameworks, developers can easily integrate it with existing projects.

Full example with Gin

main.go's content:

package main

import (
    "github.com/gin-gonic/gin"
    "github.com/TickLabVN/tonic"
    "net/http"
)

type PingResponse struct {
    Message string `json:"message"`
}

func Ping(c *gin.Context) {
    response := PingResponse{
        Message: "pong",
    }
    c.JSON(200, response)
}

func main() {
    r := gin.Default()

    tonic.Init(&tonic.Config{
        OpenAPIVersion: "3.0.0",
        Info: map[string]interface{}{
            "title":       "Go CRUD Example",
            "description": "A simple CRUD example using Go and PostgreSQL",
            "version":     "1.0.0",
        },
    })

    rg := r.Group("/api")
    {
        tonic.CreateRoutes(rg.BasePath(), []tonic.Route{
            {
                Method: tonic.Get,
                Url: "/ping",
                HandlerRegister: func(path string) {
                    rg.GET(path, Ping)
                },
                Schema: &tonic.RouteSchema{
                    Response: map[int]interface{}{
                        200: PingResponse{},
                    },
                },
            },
        })
    }

    // tonic.GetHandler() returns the net/http handler for serving the swagger documentation
    r.GET("/docs/*w", gin.WrapH(http.StripPrefix("/docs", tonic.GetHandler())))

    r.Run(":8080")
}

Result:

Forem: Nguyễn Phúc Vinh