Forem: Alex Kernel

Add authentication to your Nuxt 3 and Vue 3 applications (Logto)

Alex Kernel — Mon, 22 Dec 2025 11:45:51 +0000

Logto provides official SDKs for multiple frameworks, but the integration approach depends on your app type:

SSR / full-stack frameworks (Nuxt, Next.js, etc.) typically need a server-aware SDK that can safely store secrets and manage redirect-based flows on the server.
SPA frameworks (Vue, React, etc.) typically use a client-side SDK and rely on redirect-based login without server secrets.

In this guide, you’ll implement Logto authentication twice:
1) Nuxt 3 (SSR) using @logto/nuxt

2) Vue 3 (SPA) using Logto’s Vue SDK

No fluff — just a production-ready, copy-paste-friendly walkthrough.

Before you start: create a Logto app in the Console

In Logto Console, create an application that matches your framework:

For Nuxt 3, create a Traditional Web application.
For Vue 3, create a Single Page Application (SPA) application.

You’ll need these values for both setups:

Endpoint (your https://logto.io/ tenant URL)
App ID
(Nuxt only) App Secret

Part 1 — Nuxt 3 (SSR): add authentication with `@logto/nuxt`

Nuxt is often deployed with SSR (or hybrid rendering). Logto’s Nuxt SDK is designed for SSR and uses secure cookies + server-side handling to complete authentication.

1) Install the Nuxt SDK

npm i @logto/nuxt
# or
pnpm add @logto/nuxt
# or
yarn add @logto/nuxt

2) Add environment variables

Create a .env file:

NUXT_LOGTO_ENDPOINT="https://your-tenant.logto.app"
NUXT_LOGTO_APP_ID="your-app-id"
NUXT_LOGTO_APP_SECRET="your-app-secret"
NUXT_LOGTO_COOKIE_ENCRYPTION_KEY="a-strong-random-string"

Important: NUXT_LOGTO_COOKIE_ENCRYPTION_KEY must be a strong random string because it protects encrypted auth cookies.

3) Configure `nuxt.config.ts`

// nuxt.config.ts
export default defineNuxtConfig({
  modules: ['@logto/nuxt'],

  runtimeConfig: {
    logto: {
      endpoint: process.env.NUXT_LOGTO_ENDPOINT,
      appId: process.env.NUXT_LOGTO_APP_ID,
      appSecret: process.env.NUXT_LOGTO_APP_SECRET,
      cookieEncryptionKey: process.env.NUXT_LOGTO_COOKIE_ENCRYPTION_KEY,
    },
  },
})

4) Configure redirect URIs in Logto Console

Assuming your Nuxt app runs on http://localhost:3000:

Redirect URI: http://localhost:3000/callback
Post sign-out redirect URI: http://localhost:3000/

These must match the callback and return URLs used by the SDK.

5) Understand the built-in routes

The Nuxt module provides built-in routes for the auth flow:

/sign-in
/sign-out
/callback

You can customize them if you want:

// nuxt.config.ts
export default defineNuxtConfig({
  logto: {
    pathnames: {
      signIn: '/login',
      signOut: '/logout',
      callback: '/auth/callback',
    },
  },
})

If you change the callback path, update the redirect URI in Logto Console accordingly.

6) Implement a simple Sign in / Sign out button

<!-- pages/index.vue -->
<script setup lang="ts">
const user = useLogtoUser()
</script>

<template>
  <NuxtLink :to="`/sign-${user ? 'out' : 'in'}`">
    Sign {{ user ? 'out' : 'in' }}
  </NuxtLink>

  <pre v-if="user" style="margin-top: 16px">{{ user }}</pre>
</template>

useLogtoUser() is reactive — it updates when the session changes.

7) Request additional user claims (scopes)

By default, you get basic OIDC claims. If you need more (e.g., email/phone), add scopes:

// nuxt.config.ts
import { UserScope } from '@logto/nuxt'

export default defineNuxtConfig({
  logto: {
    scopes: [UserScope.Email, UserScope.Phone],
  },
})

8) Use the Logto client (server-only)

useLogtoClient() is server-only. On the client it returns undefined.

Example: fetch user info on the server once:

// composables/useServerUserInfo.ts
import { useLogtoClient, useState, callOnce } from '#imports'

export const useServerUserInfo = async () => {
  const client = useLogtoClient()
  const userInfo = useState<any>('logto-user-info', () => null)

  await callOnce(async () => {
    if (!client) return
    if (!(await client.isAuthenticated())) return

    userInfo.value = await client.fetchUserInfo()
  })

  return userInfo
}

Part 2 — Vue 3 (SPA): add authentication with the Vue SDK

Vue SPAs don’t have a server runtime to securely store secrets, so the recommended setup uses the Logto Vue SDK and SPA application settings in Logto Console.

1) Install the Vue SDK

Install Logto’s Vue SDK (Vue 3 only):

npm i @logto/vue
# or
pnpm add @logto/vue
# or
yarn add @logto/vue

2) Configure redirect URIs in Logto Console

Assuming your Vue app runs on http://localhost:5173:

Redirect URI: http://localhost:5173/callback
Post sign-out redirect URI: http://localhost:5173/

(Use your actual dev server origin if it’s different.)

3) Initialize Logto in `main.ts`

// src/main.ts
import { createApp } from 'vue'
import { createLogto } from '@logto/vue'
import App from './App.vue'
import router from './router'

const app = createApp(App)

app.use(
  createLogto({
    endpoint: import.meta.env.VITE_LOGTO_ENDPOINT,
    appId: import.meta.env.VITE_LOGTO_APP_ID,
  })
)

app.use(router)
app.mount('#app')

Add .env variables:

# .env
VITE_LOGTO_ENDPOINT="https://your-tenant.logto.app"
VITE_LOGTO_APP_ID="your-app-id"

4) Add a callback route

In SPAs, you must handle the redirect callback route.

Example with Vue Router:

// src/router/index.ts
import { createRouter, createWebHistory } from 'vue-router'
import Home from '../pages/Home.vue'
import Callback from '../pages/Callback.vue'

export default createRouter({
  history: createWebHistory(),
  routes: [
    { path: '/', component: Home },
    { path: '/callback', component: Callback },
  ],
})

Callback page:

<!-- src/pages/Callback.vue -->
<script setup lang="ts">
import { onMounted } from 'vue'
import { useLogto } from '@logto/vue'
import { useRouter } from 'vue-router'

const { handleSignInCallback } = useLogto()
const router = useRouter()

onMounted(async () => {
  await handleSignInCallback(window.location.href)
  router.replace('/')
})
</script>

<template>
  <p>Signing you in…</p>
</template>

5) Sign in / Sign out buttons

<!-- src/pages/Home.vue -->
<script setup lang="ts">
import { useLogto } from '@logto/vue'

const { isAuthenticated, signIn, signOut, getIdTokenClaims } = useLogto()

const handleSignIn = async () => {
  await signIn(import.meta.env.VITE_LOGTO_REDIRECT_URI)
}

const handleSignOut = async () => {
  await signOut(import.meta.env.VITE_LOGTO_POST_SIGN_OUT_REDIRECT_URI)
}
</script>

<template>
  <button v-if="!isAuthenticated" @click="handleSignIn">
    Sign in
  </button>

  <button v-else @click="handleSignOut">
    Sign out
  </button>
</template>

Add redirect-related env vars:

VITE_LOGTO_REDIRECT_URI="http://localhost:5173/callback"
VITE_LOGTO_POST_SIGN_OUT_REDIRECT_URI="http://localhost:5173/"

If you want to display the current user:

<script setup lang="ts">
import { ref } from 'vue'
import { useLogto } from '@logto/vue'

const { isAuthenticated, getIdTokenClaims } = useLogto()
const claims = ref<any>(null)

const loadClaims = async () => {
  claims.value = await getIdTokenClaims()
}
</script>

<template>
  <div v-if="isAuthenticated">
    <button @click="loadClaims">Load user claims</button>
    <pre v-if="claims">{{ claims }}</pre>
  </div>
</template>

Choosing between Nuxt and Vue integrations

If you are building a Nuxt app with SSR (or hybrid rendering), prefer @logto/nuxt because it’s designed for server-side flows and secure cookie handling.

If you are building a Vue SPA (no server runtime), use @logto/vue and the SPA application type in Logto Console.

Quick sanity check

Clicking Sign in should redirect you to Logto’s hosted sign-in screen.
After signing in, you should land on your callback route and end up back in the app.
Clicking Sign out should clear the shared session and return you to your post sign-out URL.

Final notes

This document intentionally keeps the examples minimal and production-oriented. Once authentication works, the next steps are typically:

Protecting routes (Nuxt middleware / Vue router guards)
Calling your APIs with access tokens
Adding organization/roles/permissions if your product needs it

Algolia Search in Nuxt 3: Production-Ready Integration Guide

Alex Kernel — Mon, 22 Dec 2025 10:33:23 +0000

Algolia is a hosted search engine designed for speed, relevance, and scalability. When combined with Nuxt 3, it allows you to build fast, SEO-friendly search experiences with minimal effort and full SSR support.

This guide walks through a practical, production-ready integration of Algolia in a Nuxt 3 application using the official @nuxtjs/algolia module. The focus is on real usage patterns, not abstractions.

Why Use Algolia with Nuxt 3

Nuxt 3 applications often require advanced search capabilities for blogs, documentation, dashboards, and e-commerce platforms. Algolia fits naturally into this ecosystem because it provides:

Extremely fast full-text search
Built-in typo tolerance and ranking
Seamless SSR compatibility
Auto-imported composables in Nuxt
Type-safe APIs with first-class TypeScript support

The official Nuxt Algolia module removes most of the boilerplate and exposes clean, composable APIs.

Requirements

Before starting, make sure you have:

A Nuxt 3 project
An Algolia account
At least one Algolia index with data
Algolia Application ID and Search API Key

Installing the Algolia Module

Install the official Nuxt module using the Nuxt CLI:

npx nuxi@latest module add algolia

Or with pnpm:

pnpm add @nuxtjs/algolia

The module will be registered automatically.

Environment Variables

Store Algolia credentials in environment variables.

ALGOLIA_APPLICATION_ID=YOUR_APP_ID
ALGOLIA_API_KEY=YOUR_SEARCH_API_KEY

Never commit API keys to version control.

Nuxt Configuration

Enable the module in nuxt.config.ts.

export default defineNuxtConfig({
  modules: ['@nuxtjs/algolia'],

  algolia: {
    // optional configuration
  }
})

The module automatically reads credentials from environment variables.

Basic Search Implementation

The most common way to query Algolia is via useAlgoliaSearch.

<script setup lang="ts">
const { result, search } = useAlgoliaSearch('products')

await search({ query: 'Laptop' })
</script>

<template>
  <ul>
    <li v-for="item in result.hits" :key="item.objectID">
      {{ item.name }}
    </li>
  </ul>
</template>

This performs a client-side search against the specified index.

Server-Side Search with SSR

For SEO-critical pages, use useAsyncAlgoliaSearch.

<script setup lang="ts">
const { data, pending } = await useAsyncAlgoliaSearch({
  indexName: 'products',
  query: 'Phone'
})
</script>

<template>
  <div v-if="pending">Loading…</div>
  <pre v-else>{{ data }}</pre>
</template>

This executes during server rendering and works seamlessly with Nuxt SSR.

Advanced Search Features

The module exposes additional composables:

useAlgoliaFacetedSearch for filters and facets
useAlgoliaInitIndex for index initialization
useAlgoliaRecommend for recommendations
useAlgoliaRef for direct client access

These cover most advanced search scenarios without manual client setup.

Edge and Cloudflare Support

When deploying to edge runtimes like Cloudflare Workers, enable fetch-based transport.

algolia: {
  useFetch: true
}

This ensures compatibility with restricted runtime environments.

Common Problems

No search results

Check index name
Verify index contains data
Confirm API key permissions

SSR errors

Use useAsyncAlgoliaSearch
Enable useFetch for edge runtimes

TypeScript issues

Update to the latest module version

Production Best Practices

Use SSR search only where SEO matters
Cache popular queries
Never expose Admin API keys
Index only searchable fields
Separate read and write operations

Final Notes

The official Algolia module for Nuxt 3 provides a clean and scalable way to add search to modern applications. With minimal configuration, you get fast search, SSR compatibility, and a composable API that fits naturally into the Nuxt ecosystem.

This setup is suitable for both small projects and large production systems and can be extended with InstantSearch or recommendation features when needed.

Digler — Open-Source Disk Forensics and File Recovery Tool

Alex Kernel — Sun, 21 Dec 2025 17:13:30 +0000

File Browser — Open-Source Web File Manager You Can Self-Host

Digler — Open-Source Disk Forensics and File Recovery Tool

Digler is an open-source disk forensics and file recovery utility designed for analyzing raw disks and disk images. It is written in Go, distributed as a CLI tool, and focuses on recovering deleted files and extracting forensic metadata.

GitHub repository:

https://github.com/ostafen/digler

What Problem Does Digler Solve?

When files are deleted, the file system metadata may be lost, but the raw data often remains on disk. Digler helps by:

scanning raw disks or disk images
carving files without filesystem metadata
extracting forensic evidence
producing machine-readable forensic reports

This makes it useful for:

digital forensics
incident response
data recovery
security research
educational labs

SEO keywords covered:

disk forensics tool, file recovery CLI, digital forensics Go, raw disk analysis, DFXML

Key Features

🔍 Scan raw disks and disk images
🧩 File carving without filesystem metadata
📄 DFXML (Digital Forensics XML) report generation
🧱 Modular plugin-based architecture
⚡ Cross-platform (Linux, macOS, Windows)
🔓 Open-source

High-Level Architecture

Disk / Image
   ↓
Block Scanner
   ↓
Signature Detection
   ↓
File Carving Engine
   ↓
Recovered Files + DFXML Report

The plugin system allows Digler to recognize multiple file formats.

Tech Stack

Language: Go
Interface: CLI
Output: Files + DFXML XML
Architecture: Modular / plugin-based

Installation

Build from Source

git clone https://github.com/ostafen/digler.git
cd digler
make build

The compiled binary will be available in the bin/ directory.

Basic Usage

Scan a Disk Image

digler scan disk.img

Recover Files

digler recover disk.img --output recovered_files/

Generate Forensic Report

digler scan disk.img --dfxml report.xml

The DFXML file can be used in forensic pipelines and automated analysis.

Plugin System

Digler uses plugins to identify and recover file types.

Each plugin defines:

file signature
block structure
extraction logic

This allows easy extension for new formats.

Use Cases

Digital forensics investigations
Malware and incident response
Recovering accidentally deleted files
Security training and labs
Research on file systems

Safety Notes

Always work on disk images, not live disks
Use read-only access when possible
Ensure you have legal authorization to analyze data

Why Digler Is Worth Using

Digler is valuable because it:

focuses on raw forensic workflows
avoids unnecessary UI complexity
produces structured forensic output
is easy to extend and audit

It’s a solid open-source alternative for forensic tooling.

Final Thoughts

If you work with:

disk images
forensic analysis
data recovery
security tooling

Digler is worth exploring and learning from.

File Browser — Open-Source Web File Manager You Can Self-Host

Alex Kernel — Sun, 21 Dec 2025 17:09:14 +0000

File Browser — Open-Source Web File Manager You Can Self-Host

File Browser is a fast, lightweight, open-source web-based file manager that lets you manage files on a server through a clean browser UI.

It’s written in Go, distributed as a single binary, and designed to be:

easy to deploy
easy to secure
easy to self-host

GitHub repository:

https://github.com/gtsteffaniak/filebrowser

Why File Browser Is So Popular

File Browser solves a very practical problem:

“I want to manage files on my server without SSH, FTP, or heavy admin panels.”

Instead of complex setups, File Browser gives you:

a web UI
authentication
file operations
user permissions

All in one small binary.

SEO keywords naturally included:

open-source file manager, web file browser, self-hosted file manager, Go web application, server file management

Key Features

📁 Browse files and directories from your browser
⬆️ Upload / download files
✏️ Rename, move, copy, delete
👥 User and permission management
🔐 Authentication support
⚙️ Configurable root directory
🖥️ Runs as a single Go binary
🐧 Cross-platform (Linux, macOS, Windows)

High-Level Architecture

Browser UI
   ↓
HTTP API
   ↓
File system access
   ↓
Config / auth layer

There is no heavy database dependency by default, which keeps the system simple and fast.

Tech Stack

Language: Go
Frontend: Embedded web UI
Backend: Go HTTP server
Storage: Local filesystem
Deployment: Single binary

This makes File Browser ideal for:

VPS servers
NAS devices
homelabs
internal tools

Installation Guide

File Browser is extremely easy to install.

Option 1: Download Prebuilt Binary (Recommended)

Go to the releases page
Download the binary for your OS
Make it executable

Example (Linux / macOS):

chmod +x filebrowser
./filebrowser

Option 2: Install via Package Managers

Homebrew (macOS / Linux)

brew install filebrowser

Docker

docker run   -v /path/to/your/files:/srv   -p 8080:80   filebrowser/filebrowser

Option 3: Build from Source

git clone https://github.com/gtsteffaniak/filebrowser.git
cd filebrowser
go build

First Run & Login

On first launch, File Browser will:

create a configuration file
start a web server (default port: 80 or 8080)

Open in browser:

http://localhost:8080

Default credentials:

Username: admin
Password: admin

⚠️ Change credentials immediately after login.

Basic Configuration

Common flags:

filebrowser   --root /path/to/files   --address 0.0.0.0   --port 8080

This lets you control:

which directory is exposed
network interface
port

Use Cases

File Browser is widely used for:

managing files on VPS servers
NAS and home servers
DevOps workflows
temporary file sharing
internal admin panels

It’s especially useful when:

SSH access is limited
non-technical users need access
you want a lightweight solution

Security Notes

Always change default credentials
Use HTTPS (reverse proxy recommended)
Limit root directory access
Use firewall rules where possible

File Browser is simple, but security is still your responsibility.

Why This Project Is Worth Using

File Browser stands out because it:

does one thing very well
avoids unnecessary complexity
is easy to audit
is easy to deploy anywhere

If you like small, focused open-source tools, this is a must-have.

Final Thoughts

File Browser is a great example of:

pragmatic Go development
clean self-hosted tooling
real-world open-source utility

⭐ Star the repository if you use it or learn from it.

PearPass Desktop — Open-Source Peer-to-Peer Password Manager Built on Pear Runtime

Alex Kernel — Sun, 21 Dec 2025 17:04:16 +0000

PearPass Desktop — Open-Source Peer-to-Peer Password Manager Built on Pear Runtime

If you’re tired of “password managers” that still depend on centralized cloud servers, PearPass Desktop is a refreshing direction: a distributed password manager built on Pear Runtime, designed to keep your vault data on your devices and sync it across your own endpoints.

Repo:
https://github.com/tetherto/pearpass-app-desktop

Why This Project Is Cool (and Why Devs Should Care)

PearPass Desktop is interesting for more than just end-user security:

Peer-to-peer / distributed sync mindset (no classic “one cloud to breach” architecture)
Open-source by default (easier to audit and extend)
Modern desktop stack (Pear Runtime + React ecosystem)
Great real-world reference for:
- crypto + security UX
- local-first apps
- end-to-end encryption product design
- multi-device sync without centralized infra

SEO keywords naturally covered:

open-source password manager, peer-to-peer password vault, local-first security app, end-to-end encrypted vault, Pear Runtime desktop app

Features (What You Get)

PearPass Desktop focuses on secure storage and usability:

Secure storage for passwords, identities, credit cards, notes, and custom fields
Cross-device and cross-platform synchronization
Offline access (local-first usage)
Encryption for vault security
Password strength analysis
Random password generator
Simple, clean UI

High-Level Architecture

PearPass Desktop follows a local-first model:

UI (React)
  ↓
Vault / state management
  ↓
Local encrypted storage
  ↓
Peer-to-peer distribution (Pear Runtime)

This means your “source of truth” is your devices, not a centralized web account.

Getting Started (Installation & Dev Setup)

This repo is primarily a developer setup flow (clone → install deps → run via Pear).

0) Requirements

Node.js (match the version in .nvmrc)
npm
Pear Runtime installed

Check Node version:

node --version

1) Clone the Repo

git clone https://github.com/tetherto/pearpass-app-desktop.git
cd pearpass-app-desktop

2) Update Submodules

PearPass uses submodules. Update them with the provided script:

npm run update-submodules

If you need a specific remote:

npm run update-submodules -- [remote-name]

3) Install Dependencies

npm install

4) Generate i18n (Translations)

PearPass uses Lingui. Generate and compile message catalogs:

npm run lingui:extract
npm run lingui:compile

5) Run the Desktop App (Dev Mode)

pear run --dev .

If everything is set correctly, the app should launch.

Testing

PearPass uses Jest for unit testing.

Run tests:

npm test

Usage: What to Try First

Once the app runs, a good “first session” checklist:

Create a vault and set a strong master password
Add sample entries:
- login
- note
- identity
Try password generator + strength checks
Explore sync / distribution options (if you have multiple devices)

Tech Stack

Pear Runtime
React
Styled Components
Redux
Lingui (i18n)
Jest (tests)

This is a great repo to learn how a security-focused desktop app structures:

state
encryption boundaries
UX flows for sensitive data

Who Should Fork This?

This repo is perfect if you want to build:

a local-first password manager fork
a secure “vault” module for another app
P2P sync experiments
privacy-first productivity tools

Ideas:

add hardware key / OS keychain integrations
add vault export formats
add threat-model docs + security tooling
build a plugin system for record types

Related Projects in the Ecosystem

PearPass also has:

browser extension
mobile app
vault core libraries

If you want full-stack parity (desktop + browser autofill), look at the extension repo too.

Final Notes

PearPass Desktop is one of those repos that’s both:

immediately useful
and a very teachable architecture for local-first security apps.

If you’re exploring modern, open-source security software — this is absolutely worth starring and reading.

BookHunter — Open-Source CLI Tool for Downloading and Managing eBooks

Alex Kernel — Sun, 21 Dec 2025 17:01:29 +0000

BookHunter — Open-Source CLI Tool for Downloading and Managing eBooks

BookHunter is an open-source command-line tool written in Go that allows users to download and manage eBooks from multiple online sources using a single unified CLI interface.

The project focuses on:

automation
multi-source support
cross-platform binaries
fast and simple CLI usage

GitHub repository:

https://github.com/bookstairs/bookhunter/

What Problem Does BookHunter Solve?

Downloading large collections of eBooks manually is time-consuming and repetitive.

BookHunter automates this process by providing:

a single CLI tool instead of multiple scripts
built-in parsers for different sources
multi-threaded downloads
consistent output formats

This makes it useful for:

personal libraries
research collections
automation workflows
CLI tool practice and learning

Key Features

📚 Download eBooks from multiple sources
⚡ Fast, multi-threaded downloads
🖥️ Cross-platform (Windows, macOS, Linux)
🧰 Simple and consistent CLI interface
📦 Supports common formats (PDF, EPUB, AZW3)
🔓 Open-source (MIT License)

SEO keywords covered naturally:

ebook downloader CLI, Go command line tool, open-source ebook downloader, automation with Go

Supported Sources

Depending on configuration and version, BookHunter supports:

SoBooks
TaleBook
Telegram channels
Other community-maintained sources

Each source is implemented as a separate command module.

High-Level Architecture

bookhunter (CLI)
├── source parsers
├── download manager
├── concurrency control
├── format handling
└── output directory management

The modular design makes it easy to extend with new sources.

Installation Guide

BookHunter provides prebuilt binaries for all major platforms.

macOS / Linux (Homebrew)

brew tap bookstairs/tap
brew install bookhunter

Windows (Scoop)

scoop bucket add bookstairs https://github.com/bookstairs/scoop-bucket
scoop install bookstairs/bookhunter

Manual Installation (All Platforms)

Open the GitHub releases page
Download the archive for your OS
Extract the binary
Move it to a directory in your PATH

Example (Linux / macOS):

chmod +x bookhunter
mv bookhunter /usr/local/bin/

Verify Installation

bookhunter --help

If installed correctly, you should see the available commands and options.

Basic Usage Examples

Download from SoBooks

bookhunter sobooks   --download ./ebooks   --thread 4

Download from Telegram Channel

bookhunter telegram   --appID YOUR_APP_ID   --appHash YOUR_APP_HASH   --channelID https://t.me/example_channel   --download ./tgbooks

You will need Telegram API credentials for this command.

Common Options

--download — output directory
--thread — number of concurrent downloads
--proxy — use HTTP/SOCKS proxy
--verbose — detailed logs

Use Cases

Building a personal digital library
Automating downloads in scripts
Learning Go by reading real-world CLI code
Teaching CLI tools and concurrency concepts
Research and offline reading workflows

Limitations and Notes

Availability of sources may change
Download speed depends on source limits
Users are responsible for complying with local laws and content licenses

BookHunter is a tool, not a content provider.

Why This Project Is Interesting

BookHunter is a good example of:

clean Go CLI design
modular architecture
real-world automation use cases
cross-platform distribution

It’s useful both as a tool and as a learning resource.

Final Notes

If you are interested in:

CLI tools
Go automation
managing large collections of files

BookHunter is worth checking out.

DiscovAI Search — Open‑Source AI Search Engine for Tools, Docs, and Custom Data

Alex Kernel — Sun, 21 Dec 2025 16:53:36 +0000

DiscovAI Search — Open‑Source AI Search Engine for Tools and Knowledge Bases

DiscovAI Search is an open‑source, AI‑powered search engine designed to index, understand, and search AI tools and custom knowledge bases using modern vector search + LLM reasoning.

The project combines:

semantic search (embeddings)
fast caching (Redis)
structured storage (Supabase / PostgreSQL)
modern frontend (Next.js)

It is suitable both as:

a production-ready AI search layer
an educational reference project for AI + web developers

GitHub repository:

https://github.com/DiscovAI/DiscovAI-search/

What Problem Does DiscovAI Search Solve?

Traditional keyword search fails when:

queries are vague or natural language
data is unstructured
users don’t know exact keywords

DiscovAI Search solves this by using semantic vector search, allowing users to search by meaning, not exact words.

Examples:

“tools for image generation”
“AI for document summarization”
“open-source alternatives to ChatGPT plugins”

Key Features

🔍 Semantic Search with Embeddings
🧠 LLM‑powered answer generation
⚡ Redis caching for fast responses
🗄️ Supabase (PostgreSQL + pgvector) backend
🌐 Next.js frontend
🔓 Fully open source

SEO keywords naturally covered:

AI search engine, vector search, semantic search, OpenAI embeddings, LLM search, Next.js AI app

High‑Level Architecture

User Query
   ↓
Next.js API Route
   ↓
Embedding (OpenAI)
   ↓
Vector Search (Supabase / pgvector)
   ↓
Redis Cache (optional)
   ↓
LLM‑generated response
   ↓
UI

This design keeps the system:

scalable
modular
easy to extend with new data sources

Tech Stack

Frontend: Next.js (React)
AI Models: OpenAI (embeddings + completion)
Database: Supabase (PostgreSQL + pgvector)
Cache: Redis
Language: TypeScript

Installation Guide (Local Setup)

Prerequisites

Node.js 18+
npm or yarn
OpenAI API key
Supabase account
Redis instance (local or cloud)

1. Clone the Repository

git clone https://github.com/DiscovAI/DiscovAI-search.git
cd DiscovAI-search

2. Install Dependencies

npm install
# or
yarn install

3. Environment Variables

Create a .env.local file:

OPENAI_API_KEY=your_openai_key

NEXT_PUBLIC_SUPABASE_URL=your_supabase_url
NEXT_PUBLIC_SUPABASE_ANON_KEY=your_supabase_anon_key

SUPABASE_SERVICE_ROLE_KEY=your_service_role_key

REDIS_URL=redis://localhost:6379

4. Supabase Setup

In Supabase:

Enable the pgvector extension
Create tables for:
- documents
- embeddings
Store vectors as vector columns

This enables fast semantic search.

5. Run the App

npm run dev

Open:

http://localhost:3000

You should now see the DiscovAI Search interface.

Indexing Data

DiscovAI Search can index:

AI tools
documentation
articles
internal knowledge bases

Typical flow:

Add documents to Supabase
Generate embeddings
Store vectors
Query via UI

Customization Ideas

Add your own datasets
Swap OpenAI for open‑source embedding models
Connect multiple vector indexes
Add authentication
Deploy to Vercel

Deployment

Recommended:

Frontend: Vercel
Database: Supabase
Cache: Upstash Redis

The project is cloud‑native and deploys cleanly.

Why This Project Is Useful

DiscovAI Search is valuable because it:

shows a real‑world AI search architecture
combines LLMs with vector databases correctly
is easy to fork and customize
works as both product and reference implementation

It’s a solid starting point for anyone building:

AI‑powered search
internal knowledge assistants
tool discovery platforms

Final Notes

This project demonstrates how modern AI search systems are built today, not in theory.

If you’re interested in:

semantic search
vector databases
LLM‑powered UX

DiscovAI Search is worth exploring.

Building a WoW Farming Bot with NitroGen

Alex Kernel — Sun, 21 Dec 2025 16:45:01 +0000

NitroGen is an open research project from the MineDojo / NVIDIA ecosystem.

It trains AI agents to play games purely from RGB screen pixels by imitating real human controller actions.

No game APIs.

No memory reading.

No engine hooks.

Just:

screen → neural network → controller input

In this guide, we extend NitroGen to build a vision-based farming bot for World of Warcraft (Retail, Classic, TBC, or private servers).

Important: This article is for research and educational purposes only.

Core Idea

Instead of scripting rotations or reading game memory, the agent learns by watching gameplay videos and copying human behavior.

The model:

sees health bars, enemies, minimap, cooldowns
predicts the next controller action
executes it like a human would

This makes the bot:

engine-agnostic
patch-resistant
closer to human behavior than classic bots

Key Features

Fully vision-based (no hooks, no addons)
Works with pretrained NitroGen models
Fine-tuning on your own WoW footage improves results
Human-like imperfection (non-deterministic loops)
Scales to multiple characters / accounts (research only)

What the Bot Can Do

With sufficient training data, the agent can learn:

Mob grinding
Herbalism / mining routes
Basic navigation paths
Simple combat rotations
Dungeon queue farming (LFD)

Performance depends entirely on dataset quality.

System Requirements

Windows 11 (for WoW process capture)
NVIDIA GPU (RTX 30/40 recommended, ≥8GB VRAM)
Python 3.12+
Xbox / PlayStation controller (or virtual controller via ViGEmBus)
World of Warcraft client installed
Screen resolution fixed during data collection

Installation

1. Clone NitroGen

git clone https://github.com/MineDojo/NitroGen.git
cd NitroGen

2. Create Virtual Environment

python -m venv venv
venv\Scripts\activate

3. Install Dependencies

pip install -r requirements.txt

Make sure PyTorch detects your GPU:

python -c "import torch; print(torch.cuda.is_available())"

Preparing World of Warcraft

Recommended setup:

Windowed or borderless fullscreen
Fixed resolution (e.g. 1920x1080)
Controller-friendly UI layout
Consistent camera distance
Disable UI animations where possible

NitroGen works best with stable visual layouts.

Collecting Training Data

1. Record Gameplay

Record:

grinding sessions
gathering routes
combat encounters

At the same time, record:

controller inputs
button presses
joystick movements

This produces:

frame_t → action_t

pairs for training.

2. Dataset Structure

Example:

dataset/
├── frames/
│   ├── 000001.png
│   ├── 000002.png
│   └── ...
└── actions/
    ├── 000001.json
    ├── 000002.json
    └── ...

Training the Model

Fine-tune NitroGen on WoW footage:

python scripts/train.py \
  --config configs/wow_train.yaml \
  --dataset datasets/wow_grinding

Key parameters:

frame resolution
temporal window size
action discretization
batch size

Training is much more stable than reinforcement learning.

Running the Bot

python scripts/run_agent.py \
  --config configs/wow_eval.yaml \
  --checkpoint checkpoints/wow_finetuned.pt

The agent will:

read frames from the WoW window
predict controller actions
execute them in real time

Limitations

No long-term quest planning
Weak at PvP
Sensitive to UI changes
Requires significant training data
Not competitive with human players

This is a research agent, not a perfect farmer.

Detection and Ethics

NitroGen:

does not inject code
does not read memory
does not modify the client

However:

automation is still detectable on live servers
Blizzard actively bans bots

Use responsibly.

Why This Matters

World of Warcraft is one of the richest interactive environments ever built.

Using it as a benchmark helps research:

embodied AI
vision-based control
human-like decision making
long-horizon tasks

The techniques here apply far beyond games.

Forem: Alex Kernel

Add authentication to your Nuxt 3 and Vue 3 applications (Logto)

Before you start: create a Logto app in the Console

Part 1 — Nuxt 3 (SSR): add authentication with @logto/nuxt

1) Install the Nuxt SDK

2) Add environment variables

3) Configure nuxt.config.ts

4) Configure redirect URIs in Logto Console

5) Understand the built-in routes

6) Implement a simple Sign in / Sign out button

7) Request additional user claims (scopes)

8) Use the Logto client (server-only)

Part 2 — Vue 3 (SPA): add authentication with the Vue SDK

1) Install the Vue SDK

2) Configure redirect URIs in Logto Console

3) Initialize Logto in main.ts

4) Add a callback route

5) Sign in / Sign out buttons

Choosing between Nuxt and Vue integrations

Quick sanity check

Final notes

Algolia Search in Nuxt 3: Production-Ready Integration Guide

Why Use Algolia with Nuxt 3

Requirements

Installing the Algolia Module

Environment Variables

Nuxt Configuration

Basic Search Implementation

Server-Side Search with SSR

Advanced Search Features

Edge and Cloudflare Support

Common Problems

Production Best Practices

Final Notes

Digler — Open-Source Disk Forensics and File Recovery Tool

File Browser — Open-Source Web File Manager You Can Self-Host

Digler — Open-Source Disk Forensics and File Recovery Tool

What Problem Does Digler Solve?

Key Features

High-Level Architecture

Tech Stack

Installation

Basic Usage

Scan a Disk Image

Recover Files

Generate Forensic Report

Plugin System

Use Cases

Safety Notes

Why Digler Is Worth Using

Final Thoughts

File Browser — Open-Source Web File Manager You Can Self-Host

File Browser — Open-Source Web File Manager You Can Self-Host

Why File Browser Is So Popular

Key Features

High-Level Architecture

Tech Stack

Installation Guide

Option 1: Download Prebuilt Binary (Recommended)

Option 2: Install via Package Managers

Homebrew (macOS / Linux)

Docker

Option 3: Build from Source

First Run & Login

Basic Configuration

Use Cases

Security Notes

Why This Project Is Worth Using

Final Thoughts

PearPass Desktop — Open-Source Peer-to-Peer Password Manager Built on Pear Runtime

PearPass Desktop — Open-Source Peer-to-Peer Password Manager Built on Pear Runtime

Why This Project Is Cool (and Why Devs Should Care)

Features (What You Get)

High-Level Architecture

Getting Started (Installation & Dev Setup)

0) Requirements

1) Clone the Repo

2) Update Submodules

3) Install Dependencies

4) Generate i18n (Translations)

Part 1 — Nuxt 3 (SSR): add authentication with `@logto/nuxt`

3) Configure `nuxt.config.ts`

3) Initialize Logto in `main.ts`