# Andromeda: Rust vs Go Performance Comparison

Comparison of the Rust apps (current production, running in Docker) against the in-progress Go rewrites on the `chore/go-rewrite` branch.

Date: 2026-05-16

Host: Linux 7.0.3-arch1-2

## Methodology

- **Binary size**: `cargo build --release --workspace` (with `[profile.release]` defaults) vs each `go build` artifact in `apps/*-go/`. Raw stripped/unstripped binaries on disk, no UPX or other post-processing.

- **Lines of code**: Total lines in `apps/<app>/src/**/*.rs` vs `apps/<app>-go/**/*.go`. Includes blanks and comments. Shared crates counted separately.

- **Dependencies**: Direct deps parsed from `Cargo.toml` `[dependencies]` vs `require ( ... )` blocks in `go.mod` (separating direct vs total-with-indirect).

- **RAM**: Two passes.

  1. *Production snapshot* — `docker stats` against the long-running Rust containers (not apples-to-apples; reflects accumulated state).

  2. *Fair cold start* — local release binaries (Rust from `target/release/`, Go from `apps/*-go/`) launched on unused ports with `PORT`/`HOST` overrides, sampled `VmRSS` from `/proc/<pid>/status` after a 2s warmup, then terminated. Same conditions, no traffic, fresh sqlite.

## Binary Size

| App       | Rust   | Go     | Go vs Rust |

|-----------|--------|--------|------------|

| bookmarks | 14M    | 20M    | +43%       |

| cellar    | 16M    | 20M    | +25%       |

| easel     | 15M    | 20M    | +33%       |

| feeds     | 16M    | 23M    | +44%       |

| jotts     | 19M    | 21M    | +11%       |

| library   | 13M    | 20M    | +54%       |

| og        | 12M    | 14M    | +17%       |

| posts     | 16M    | 21M    | +31%       |

| shrink    | 8.2M   | 14M    | +71%       |

| sipp      | 16M    | 22M    | +38%       |

**Winner: Rust** — smaller in every app, average ~35% smaller.

## Lines of Code

Raw totals:

| App       | Rust  | Go    | Go ratio |

|-----------|-------|-------|----------|

| bookmarks | 850   | 756   | 0.89x    |

| cellar    | 2010  | 1241  | 0.62x    |

| easel     | 1156  | 946   | 0.82x    |

| feeds     | 2193  | 1981  | 0.90x    |

| jotts     | 2248  | 526   | 0.23x    |

| library   | 1021  | 882   | 0.86x    |

| og        | 399   | 295   | 0.74x    |

| posts     | 3010  | 2140  | 0.71x    |

| shrink    | 389   | 166   | 0.43x    |

| sipp      | 2455  | 655   | 0.27x    |

### TUI/CLI adjustment

`jotts` and `sipp` Rust binaries include a full TUI/CLI alongside the server. Go ports are server-only. Stripping TUI sources for a fair compare:

| App   | Rust server only | Rust TUI/CLI | Go    | Go ratio (server) |

|-------|------------------|--------------|-------|--------------------|

| jotts | 1063             | 1185         | 526   | 0.49x              |

| sipp  | 1203             | 1252         | 655   | 0.54x              |

All other apps are server-only on both sides — raw numbers are already fair.

### Shared modules

| Side  | Modules                                  | Total LOC |

|-------|------------------------------------------|-----------|

| Rust  | `crates/auth` (371), `crates/db` (833), `crates/darkmatter-css` (54) | 1258 |

| Go    | `crates-go/auth` (207), `crates-go/config` (58), `crates-go/darkmatter` (54), `crates-go/web` (72) | 391 |

**Winner: Go** — consistently fewer lines (~30–50% less for server code).

## Dependencies

| App       | Rust direct | Go direct | Go +indirect |

|-----------|-------------|-----------|---------------|

| bookmarks | 22          | 6         | 17            |

| cellar    | 24          | 5         | 16            |

| easel     | 19          | 4         | 14            |

| feeds     | 25          | 7         | 25            |

| jotts     | 29          | 6         | 17            |

| library   | 20          | 5         | 16            |

| og        | 15          | 4         | 4             |

| posts     | 26          | 6         | 17            |

| shrink    | 11          | 4         | 4             |

| sipp      | 32          | 6         | 18            |

**Winner: Go** — far fewer direct deps; stdlib carries weight. Rust transitive trees would be much larger again if expanded via `cargo tree`.

## RAM Usage

### Production snapshot (Rust in Docker, idle)

Long-running containers from `docker stats --no-stream`. Includes accumulated state (background pollers in `cellar`/`feeds` inflate RSS).

| App       | RSS    |

|-----------|--------|

| og        | 7.5M   |

| shrink    | 6.3M   |

| jotts     | 13.0M  |

| library   | 13.1M  |

| sipp      | 13.3M  |

| bookmarks | 22.1M  |

| posts     | 23.2M  |

| easel     | 31.5M  |

| feeds     | 52.1M  |

| cellar    | 64.6M  |

Not comparable to a cold Go binary — different uptime and workload.

### Fair cold start (both sides, alt ports, 2s warmup)

| App       | Rust    | Go      | Winner          |

|-----------|---------|---------|-----------------|

| bookmarks | 11.2M   | 13.6M   | Rust −18%       |

| cellar    | 10.5M   | 12.9M   | Rust −19%       |

| easel     | 21.1M   | 12.8M   | **Go −39%**     |

| feeds     | 11.6M   | 14.3M   | Rust −19%       |

| jotts     | 8.6M    | 14.2M   | Rust −39%       |

| library   | 10.1M   | 12.6M   | Rust −20%       |

| og        | 8.1M    | 10.1M   | Rust −20%       |

| posts     | 10.8M   | 14.9M   | Rust −28%       |

| shrink    | 5.6M    | 9.9M    | Rust −44%       |

| sipp      | 10.1M   | 19.6M   | Rust −48%       |

**Winner: Rust** — 9 of 10 apps. Average ~28% less RAM cold idle. Easel anomaly: Rust eagerly loads classifications/exclusion lists at boot.

## Summary

| Metric                       | Winner | Magnitude              |

|------------------------------|--------|------------------------|

| Binary size                  | Rust   | ~35% smaller avg       |

| Lines of code (server only)  | Go     | ~30–50% fewer          |

| Direct dependencies          | Go     | 4–7 vs 11–32           |

| RAM (cold start, single user)| Rust   | ~28% less avg, 9/10    |

### Context: single-user deployment

Apps are single-user. Cold-start RAM is the right benchmark — no concurrent load spike, no GC pressure differences under traffic, idle is the dominant state.

- Rust: smaller binaries, lower idle RAM, more code, more deps.

- Go: less code, fewer deps, larger binaries, higher idle RAM.

Tradeoff is roughly: pay in source-code volume + dep count to get smaller binaries and lower memory; or pay in binary size + RAM to get less code to maintain.

A collection of minimal, self-hosted web apps. Each app compiles to a single

binary. The original implementation is a Rust workspace (Axum + Askama). A

parallel Go port lives alongside, sharing the same SQLite schemas and routes

so either implementation can serve the same data.

## Go ports

The same apps are being rewritten in Go under `apps/<name>-go/`. Each one is

a separate Go module that embeds its templates and static assets and uses

shared packages from `crates-go/`. Status:

| Go app | Notes |

|---|---|

| `apps/feeds-go` | full parity |

| `apps/jotts-go` | full parity |

| `apps/og-go` | full parity |

| `apps/shrink-go` | EXIF reinjection dropped |

| `apps/bookmarks-go` | full parity |

| `apps/library-go` | full parity |

| `apps/easel-go` | full parity |

| `apps/cellar-go` | EXIF orientation auto-rotate dropped |

| `apps/posts-go` | local FS only (no R2/S3) |

| `apps/sipp-go` | server + CLI; interactive TUI not ported |

`apps/parcels-go` is intentionally not built (USPS API access has changed).

Each Go app references the shared `crates-go/` packages via `replace`

directives in its `go.mod`, so the source tree is fully self-contained.

## Shared crates

Rust:

| [`andromeda-darkmatter-css`](crates/darkmatter-css) | Shared CSS + fonts |

Go (each is its own module under `crates-go/`):

| Package | Description |

|---|---|

| `crates-go/web` | HTTP helpers (embedded assets, JSON, render, redirect) |

| `crates-go/auth` | Sessions store, password/api-key verification, short-id |

| `crates-go/config` | env + `.env` loading helpers |

| `crates-go/darkmatter` | Embedded CSS + fonts, mountable on any `http.ServeMux` |

Rust apps: Axum + rusqlite + Askama + rust-embed + tokio.

Go apps: stdlib `net/http` + `modernc.org/sqlite` (pure Go, no cgo) +

`html/template` + `embed.FS`. Permitted extras: `goldmark` (markdown),

`gofeed` (RSS), `golang.org/x/net/html` (HTML parsing),

`golang.org/x/image/draw` (image resize), `alecthomas/chroma` (highlight),

`golang.org/x/crypto/bcrypt` (passwords).

Rust:

```

Go:

```bash

cd apps/feeds-go && cp .env.example .env && go run .

cd apps/posts-go && cp .env.example .env && go run .

# sipp-go has two binaries:

cd apps/sipp-go && go run ./cmd/server

HOST=127.0.0.1

PORT=3000

# SQLite file path

BOOKMARKS_DB_PATH=bookmarks.sqlite

# Admin login password

BOOKMARKS_PASSWORD=changeme

# API key for POST /api/links (omit to disable write API)

BOOKMARKS_API_KEY=

# Set true behind HTTPS to mark session cookie Secure

COOKIE_SECURE=false

# Build from repo root: docker build -t bookmarks-go -f apps/bookmarks-go/Dockerfile .

FROM golang:1.24-bookworm AS builder

WORKDIR /app

COPY crates-go/ ./crates-go/

COPY apps/bookmarks-go/go.mod apps/bookmarks-go/go.sum ./apps/bookmarks-go/

WORKDIR /app/apps/bookmarks-go

RUN go mod download

COPY apps/bookmarks-go/ ./

RUN CGO_ENABLED=0 go build -o /bookmarks-go .

FROM debian:bookworm-slim

RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*

COPY --from=builder /bookmarks-go /usr/local/bin/bookmarks-go

WORKDIR /data

ENV HOST=0.0.0.0

ENV PORT=3000

EXPOSE 3000

CMD ["bookmarks-go"]

# bookmarks-go

Go rewrite of [bookmarks](../bookmarks). Personal link saver organized by

category.

## Quickstart

```bash

cp .env.example .env

go run .

```

### Environment Variables

| Variable | Default | Description |

|---|---|---|

| `BOOKMARKS_PASSWORD` | — | Admin panel password |

| `BOOKMARKS_API_KEY` | — | API key for `POST /api/links` |

| `BOOKMARKS_DB_PATH` | `bookmarks.sqlite` | SQLite path |

| `HOST` | `127.0.0.1` | Bind host |

| `PORT` | `3000` | Server port |

| `COOKIE_SECURE` | `false` | Mark session cookie Secure |

## Routes

Public: `GET /`, `GET /api/categories`, `GET /api/links`. Auth: `GET/POST /login`,

`GET /logout`, `/admin`, `/admin/*`. API-key: `POST /api/links`.

package main

import (

	"database/sql"

	"embed"

	"html/template"

	"log/slog"

	"github.com/stevedylandev/andromeda/crates-go/auth"

)

//go:embed templates/*.html static/*

var appFS embed.FS

type App struct {

	DB           *sql.DB

	Log          *slog.Logger

	Templates    *template.Template

	Sessions     *auth.Store

	Password     string

	APIKey       string

	CookieSecure bool

}

type Category struct {

	ID       int64  `json:"id"`

	ShortID  string `json:"short_id"`

	Name     string `json:"name"`

	Position int64  `json:"position"`

}

type Link struct {

	ID         int64   `json:"id"`

	ShortID    string  `json:"short_id"`

	Title      string  `json:"title"`

	URL        string  `json:"url"`

	FaviconURL *string `json:"favicon_url,omitempty"`

	CategoryID int64   `json:"category_id"`

	CreatedAt  int64   `json:"created_at"`

}

type adminLinkRow struct {

	ShortID    string

	Title      string

	URL        string

	FaviconURL *string

	Category   string

}

type categoryGroup struct {

	Name  string

	Links []Link

}

type indexPageData struct {

	Groups []categoryGroup

}

type loginPageData struct {

	Error string

}

type adminPageData struct {

	Success    string

	Error      string

	Categories []Category

	Links      []adminLinkRow

}

type apiCreateLinkBody struct {

	Category string `json:"category"`

	Title    string `json:"title"`

	URL      string `json:"url"`

}

package main

import (

	"database/sql"

	"errors"

	"strings"

	"time"

	"github.com/stevedylandev/andromeda/crates-go/auth"

	_ "modernc.org/sqlite"

)

const schema = `

CREATE TABLE IF NOT EXISTS categories (

    id         INTEGER PRIMARY KEY AUTOINCREMENT,

    short_id   TEXT NOT NULL UNIQUE,

    name       TEXT NOT NULL UNIQUE,

    position   INTEGER NOT NULL DEFAULT 0,

    created_at INTEGER NOT NULL

);

CREATE TABLE IF NOT EXISTS links (

    id           INTEGER PRIMARY KEY AUTOINCREMENT,

    short_id     TEXT NOT NULL UNIQUE,

    title        TEXT NOT NULL,

    url          TEXT NOT NULL,

    favicon_url  TEXT,

    category_id  INTEGER NOT NULL REFERENCES categories(id) ON DELETE CASCADE,

    created_at   INTEGER NOT NULL

);

CREATE INDEX IF NOT EXISTS idx_links_category ON links(category_id, created_at DESC);

`

func openDB(path string) (*sql.DB, error) {

	db, err := sql.Open("sqlite", path)

	if err != nil {

		return nil, err

	}

	db.SetMaxOpenConns(1)

	db.SetMaxIdleConns(1)

	if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {

		return nil, err

	}

	if _, err := db.Exec(schema); err != nil {

		return nil, err

	}

	return db, nil

}

func listCategories(db *sql.DB) ([]Category, error) {

	rows, err := db.Query(`SELECT id, short_id, name, position FROM categories ORDER BY position ASC, name COLLATE NOCASE`)

	if err != nil {

		return nil, err

	}

	defer rows.Close()

	out := []Category{}

	for rows.Next() {

		var c Category

		if err := rows.Scan(&c.ID, &c.ShortID, &c.Name, &c.Position); err != nil {

			return nil, err

		}

		out = append(out, c)

	}

	return out, rows.Err()

}

func createCategory(db *sql.DB, name string) (*Category, error) {

	shortID, err := auth.GenerateShortID(10)

	if err != nil {

		return nil, err

	}

	now := time.Now().UTC().Unix()

	var nextPos int64

	if err := db.QueryRow(`SELECT COALESCE(MAX(position), 0) + 1 FROM categories`).Scan(&nextPos); err != nil {

		return nil, err

	}

	res, err := db.Exec(`INSERT INTO categories (short_id, name, position, created_at) VALUES (?, ?, ?, ?)`, shortID, name, nextPos, now)

	if err != nil {

		return nil, err

	}

	id, _ := res.LastInsertId()

	return &Category{ID: id, ShortID: shortID, Name: name, Position: nextPos}, nil

}

func deleteCategoryByShortID(db *sql.DB, shortID string) (bool, error) {

	res, err := db.Exec(`DELETE FROM categories WHERE short_id = ?`, shortID)

	if err != nil {

		return false, err

	}

	n, _ := res.RowsAffected()

	return n > 0, nil

}

func moveCategory(db *sql.DB, shortID string, direction int) (bool, error) {

	tx, err := db.Begin()

	if err != nil {

		return false, err

	}

	defer tx.Rollback()

	var curID, curPos int64

	err = tx.QueryRow(`SELECT id, position FROM categories WHERE short_id = ?`, shortID).Scan(&curID, &curPos)

	if errors.Is(err, sql.ErrNoRows) {

		return false, nil

	}

	if err != nil {

		return false, err

	}

	var nbID, nbPos int64

	if direction < 0 {

		err = tx.QueryRow(`SELECT id, position FROM categories WHERE position < ? ORDER BY position DESC LIMIT 1`, curPos).Scan(&nbID, &nbPos)

	} else {

		err = tx.QueryRow(`SELECT id, position FROM categories WHERE position > ? ORDER BY position ASC LIMIT 1`, curPos).Scan(&nbID, &nbPos)

	}

	if errors.Is(err, sql.ErrNoRows) {

		return false, nil

	}

	if err != nil {

		return false, err

	}

	if _, err := tx.Exec(`UPDATE categories SET position = ? WHERE id = ?`, nbPos, curID); err != nil {

		return false, err

	}

	if _, err := tx.Exec(`UPDATE categories SET position = ? WHERE id = ?`, curPos, nbID); err != nil {

		return false, err

	}

	if err := tx.Commit(); err != nil {

		return false, err

	}

	return true, nil

}

func getCategoryByName(db *sql.DB, name string) (*Category, error) {

	name = strings.TrimSpace(name)

	var c Category

	err := db.QueryRow(`SELECT id, short_id, name, position FROM categories WHERE name = ?`, name).Scan(&c.ID, &c.ShortID, &c.Name, &c.Position)

	if errors.Is(err, sql.ErrNoRows) {

		return nil, nil

	}

	if err != nil {

		return nil, err

	}

	return &c, nil

}

func listLinks(db *sql.DB) ([]Link, error) {

	rows, err := db.Query(`SELECT id, short_id, title, url, favicon_url, category_id, created_at FROM links ORDER BY created_at DESC`)

	if err != nil {

		return nil, err

	}

	defer rows.Close()

	out := []Link{}

	for rows.Next() {

		var l Link

		var fav sql.NullString

		if err := rows.Scan(&l.ID, &l.ShortID, &l.Title, &l.URL, &fav, &l.CategoryID, &l.CreatedAt); err != nil {

			return nil, err

		}

		if fav.Valid && fav.String != "" {

			s := fav.String

			l.FaviconURL = &s

		}

		out = append(out, l)

	}

	return out, rows.Err()

}

func createLink(db *sql.DB, title, url string, faviconURL *string, categoryID int64) (*Link, error) {

	shortID, err := auth.GenerateShortID(10)

	if err != nil {

		return nil, err

	}

	now := time.Now().UTC().Unix()

	var fav any

	if faviconURL != nil && *faviconURL != "" {

		fav = *faviconURL

	}

	res, err := db.Exec(`INSERT INTO links (short_id, title, url, favicon_url, category_id, created_at) VALUES (?, ?, ?, ?, ?, ?)`,

		shortID, title, url, fav, categoryID, now)

	if err != nil {

		return nil, err

	}

	id, _ := res.LastInsertId()

	link := &Link{ID: id, ShortID: shortID, Title: title, URL: url, CategoryID: categoryID, CreatedAt: now}

	if faviconURL != nil && *faviconURL != "" {

		s := *faviconURL

		link.FaviconURL = &s

	}

	return link, nil

}

func listLinksMissingFavicon(db *sql.DB) ([]struct {

	ID  int64

	URL string

}, error) {

	rows, err := db.Query(`SELECT id, url FROM links WHERE favicon_url IS NULL OR favicon_url = ''`)

	if err != nil {

		return nil, err

	}

	defer rows.Close()

	var out []struct {

		ID  int64

		URL string

	}

	for rows.Next() {

		var r struct {

			ID  int64

			URL string

		}

		if err := rows.Scan(&r.ID, &r.URL); err != nil {

			return nil, err

		}

		out = append(out, r)

	}

	return out, rows.Err()

}

func updateLinkFavicon(db *sql.DB, id int64, favicon *string) error {

	var v any

	if favicon != nil && *favicon != "" {

		v = *favicon

	}

	_, err := db.Exec(`UPDATE links SET favicon_url = ? WHERE id = ?`, v, id)

	return err

}

func deleteLinkByShortID(db *sql.DB, shortID string) (bool, error) {

	res, err := db.Exec(`DELETE FROM links WHERE short_id = ?`, shortID)

	if err != nil {

		return false, err

	}

	n, _ := res.RowsAffected()

	return n > 0, nil

}

services:

  app:

    build:

      context: ../..

      dockerfile: apps/bookmarks-go/Dockerfile

    ports:

      - "${PORT:-3000}:${PORT:-3000}"

    environment:

      - HOST=0.0.0.0

      - PORT=${PORT:-3000}

      - BOOKMARKS_DB_PATH=/data/bookmarks-go.sqlite

      - BOOKMARKS_PASSWORD=${BOOKMARKS_PASSWORD:-changeme}

      - BOOKMARKS_API_KEY=${BOOKMARKS_API_KEY:-}

      - COOKIE_SECURE=${COOKIE_SECURE:-false}

    volumes:

      - bookmarks-go-data:/data

    restart: unless-stopped

volumes:

  bookmarks-go-data:

package main

import (

	"context"

	"io"

	"net/http"

	"net/url"

	"strings"

	"time"

	"golang.org/x/net/html"

)

const faviconUA = "andromeda-bookmarks-go/0.1 (+https://github.com/stevedylandev/andromeda)"

func discoverFavicon(ctx context.Context, pageURL string) string {

	parsed, err := url.Parse(pageURL)

	if err != nil {

		return ""

	}

	client := &http.Client{Timeout: 15 * time.Second}

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, pageURL, nil)

	if err != nil {

		return ""

	}

	req.Header.Set("User-Agent", faviconUA)

	if resp, err := client.Do(req); err == nil {

		defer resp.Body.Close()

		body, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<20))

		if href := findFaviconHref(string(body)); href != "" {

			if u, err := parsed.Parse(href); err == nil {

				return u.String()

			}

		}

	}

	if u, err := parsed.Parse("/favicon.ico"); err == nil {

		return u.String()

	}

	return ""

}

func findFaviconHref(doc string) string {

	node, err := html.Parse(strings.NewReader(doc))

	if err != nil {

		return ""

	}

	wants := []string{"icon", "shortcut icon", "apple-touch-icon"}

	var found string

	var walk func(*html.Node)

	walk = func(n *html.Node) {

		if found != "" {

			return

		}

		if n.Type == html.ElementNode && strings.EqualFold(n.Data, "link") {

			rel, href := "", ""

			for _, a := range n.Attr {

				switch strings.ToLower(a.Key) {

				case "rel":

					rel = strings.ToLower(strings.TrimSpace(a.Val))

				case "href":

					href = a.Val

				}

			}

			for _, want := range wants {

				if rel == want {

					if href != "" {

						found = href

					}

					return

				}

			}

		}

		for c := n.FirstChild; c != nil; c = c.NextSibling {

			walk(c)

		}

	}

	walk(node)

	return found

}

module github.com/stevedylandev/andromeda/apps/bookmarks-go

go 1.24.4

require (

	github.com/stevedylandev/andromeda/crates-go/auth v0.0.0

	github.com/stevedylandev/andromeda/crates-go/config v0.0.0

	github.com/stevedylandev/andromeda/crates-go/darkmatter v0.0.0

	github.com/stevedylandev/andromeda/crates-go/web v0.0.0

	golang.org/x/net v0.41.0

	modernc.org/sqlite v1.37.1

)

require (

	github.com/dustin/go-humanize v1.0.1 // indirect

	github.com/google/uuid v1.6.0 // indirect

	github.com/mattn/go-isatty v0.0.20 // indirect

	github.com/ncruces/go-strftime v0.1.9 // indirect

	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect

	golang.org/x/crypto v0.39.0 // indirect

	golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 // indirect

	golang.org/x/sys v0.33.0 // indirect

	modernc.org/libc v1.65.7 // indirect

	modernc.org/mathutil v1.7.1 // indirect

	modernc.org/memory v1.11.0 // indirect

)

replace (

	github.com/stevedylandev/andromeda/crates-go/auth => ../../crates-go/auth

	github.com/stevedylandev/andromeda/crates-go/config => ../../crates-go/config

	github.com/stevedylandev/andromeda/crates-go/darkmatter => ../../crates-go/darkmatter

	github.com/stevedylandev/andromeda/crates-go/web => ../../crates-go/web

)

github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=

github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=

github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=

github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=

github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=

github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=

github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=

github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=

github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=

github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=

github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=

github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=

golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=

golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=

golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5ZsaDtB+a39EqjV0JSUM=

golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8=

golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU=

golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=

golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=

golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=

golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=

golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=

golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=

golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=

golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=

golang.org/x/tools v0.33.0 h1:4qz2S3zmRxbGIhDIAgjxvFutSvH5EfnsYrRBj0UI0bc=

golang.org/x/tools v0.33.0/go.mod h1:CIJMaWEY88juyUfo7UbgPqbC8rU2OqfAV1h2Qp0oMYI=

modernc.org/cc/v4 v4.26.1 h1:+X5NtzVBn0KgsBCBe+xkDC7twLb/jNVj9FPgiwSQO3s=

modernc.org/cc/v4 v4.26.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=

modernc.org/ccgo/v4 v4.28.0 h1:rjznn6WWehKq7dG4JtLRKxb52Ecv8OUGah8+Z/SfpNU=

modernc.org/ccgo/v4 v4.28.0/go.mod h1:JygV3+9AV6SmPhDasu4JgquwU81XAKLd3OKTUDNOiKE=

modernc.org/fileutil v1.3.1 h1:8vq5fe7jdtEvoCf3Zf9Nm0Q05sH6kGx0Op2CPx1wTC8=

modernc.org/fileutil v1.3.1/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=

modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=

modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=

modernc.org/libc v1.65.7 h1:Ia9Z4yzZtWNtUIuiPuQ7Qf7kxYrxP1/jeHZzG8bFu00=

modernc.org/libc v1.65.7/go.mod h1:011EQibzzio/VX3ygj1qGFt5kMjP0lHb0qCW5/D/pQU=

modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=

modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=

modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=

modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=

modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=

modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=

modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=

modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=

modernc.org/sqlite v1.37.1 h1:EgHJK/FPoqC+q2YBXg7fUmES37pCHFc97sI7zSayBEs=

modernc.org/sqlite v1.37.1/go.mod h1:XwdRtsE1MpiBcL54+MbKcaDvcuej+IYSMfLN6gSKV8g=

modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=

modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=

modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=

modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=

package main

import (

	"net/http"

	"strings"

	"github.com/stevedylandev/andromeda/crates-go/web"

)

func (a *App) apiListCategories(w http.ResponseWriter, r *http.Request) {

	cats, err := listCategories(a.DB)

	if err != nil {

		a.Log.Error("list categories", "err", err)

		w.WriteHeader(http.StatusInternalServerError)

		return

	}

	web.WriteJSON(w, http.StatusOK, cats)

}

func (a *App) apiListLinks(w http.ResponseWriter, r *http.Request) {

	cats, err := listCategories(a.DB)

	if err != nil {

		a.Log.Error("list categories", "err", err)

		w.WriteHeader(http.StatusInternalServerError)

		return

	}

	links, err := listLinks(a.DB)

	if err != nil {

		a.Log.Error("list links", "err", err)

		w.WriteHeader(http.StatusInternalServerError)

		return

	}

	filter := strings.TrimSpace(r.URL.Query().Get("category"))

	if filter != "" {

		var found *Category

		for i := range cats {

			if strings.EqualFold(cats[i].Name, filter) {

				found = &cats[i]

				break

			}

		}

		if found == nil {

			web.WriteJSON(w, http.StatusNotFound, map[string]any{"error": "unknown category"})

			return

		}

		out := []Link{}

		for _, l := range links {

			if l.CategoryID == found.ID {

				out = append(out, l)

			}

		}

		web.WriteJSON(w, http.StatusOK, out)

		return

	}

	grouped := map[string][]Link{}

	for _, c := range cats {

		items := []Link{}

		for _, l := range links {

			if l.CategoryID == c.ID {

				items = append(items, l)

			}

		}

		grouped[c.Name] = items

	}

	web.WriteJSON(w, http.StatusOK, grouped)

}

func (a *App) apiCreateLink(w http.ResponseWriter, r *http.Request) {

	var body apiCreateLinkBody

	if !web.DecodeJSON(w, r, &body) {

		return

	}

	title := strings.TrimSpace(body.Title)

	url := strings.TrimSpace(body.URL)

	if title == "" || url == "" {

		web.WriteJSON(w, http.StatusBadRequest, map[string]any{"error": "title and url required"})

		return

	}

	cat, err := getCategoryByName(a.DB, body.Category)

	if err != nil {

		a.Log.Error("get category", "err", err)

		w.WriteHeader(http.StatusInternalServerError)

		return

	}

	if cat == nil {

		web.WriteJSON(w, http.StatusNotFound, map[string]any{"error": "unknown category"})

		return

	}

	link, err := createLink(a.DB, title, url, nil, cat.ID)

	if err != nil {

		a.Log.Error("create link", "err", err)

		w.WriteHeader(http.StatusInternalServerError)

		return

	}

	if fav := discoverFavicon(r.Context(), url); fav != "" {

		_ = updateLinkFavicon(a.DB, link.ID, &fav)

		link.FaviconURL = &fav

	}

	web.WriteJSON(w, http.StatusCreated, link)

}

package main

import (

	"context"

	"net/http"

	"strings"

	"github.com/stevedylandev/andromeda/crates-go/auth"

	"github.com/stevedylandev/andromeda/crates-go/web"

)

func (a *App) indexHandler(w http.ResponseWriter, r *http.Request) {

	cats, _ := listCategories(a.DB)

	links, _ := listLinks(a.DB)

	groups := make([]categoryGroup, 0, len(cats))

	for _, c := range cats {

		group := categoryGroup{Name: c.Name}

		for _, l := range links {

			if l.CategoryID == c.ID {

				group.Links = append(group.Links, l)

			}

		}

		groups = append(groups, group)

	}

	web.Render(a.Templates, w, "index.html", indexPageData{Groups: groups}, a.Log)

}

func (a *App) loginGetHandler(w http.ResponseWriter, r *http.Request) {

	web.Render(a.Templates, w, "login.html", loginPageData{Error: r.URL.Query().Get("error")}, a.Log)

}

func (a *App) loginPostHandler(w http.ResponseWriter, r *http.Request) {

	if a.Password == "" {

		web.RedirectWithError(w, r, "/login", "No password configured")

		return

	}

	if err := r.ParseForm(); err != nil {

		web.RedirectWithError(w, r, "/login", "Bad request")

		return

	}

	if !auth.VerifyPassword(r.FormValue("password"), a.Password) {

		web.RedirectWithError(w, r, "/login", "Invalid password")

		return

	}

	token, err := a.Sessions.Create()

	if err != nil {

		a.Log.Error("create session failed", "err", err)

		web.RedirectWithError(w, r, "/login", "Session error")

		return

	}

	a.Sessions.PruneExpired()

	http.SetCookie(w, a.Sessions.SessionCookie(token))

	http.Redirect(w, r, "/admin", http.StatusSeeOther)

}

func (a *App) logoutHandler(w http.ResponseWriter, r *http.Request) {

	if c, err := r.Cookie(a.Sessions.CookieName); err == nil && c.Value != "" {

		a.Sessions.Delete(c.Value)

	}

	http.SetCookie(w, a.Sessions.ClearCookie())

	http.Redirect(w, r, "/login", http.StatusSeeOther)

}

func (a *App) adminHandler(w http.ResponseWriter, r *http.Request) {

	cats, _ := listCategories(a.DB)

	raw, _ := listLinks(a.DB)

	catName := map[int64]string{}

	for _, c := range cats {

		catName[c.ID] = c.Name

	}

	rows := make([]adminLinkRow, 0, len(raw))

	for _, l := range raw {

		rows = append(rows, adminLinkRow{ShortID: l.ShortID, Title: l.Title, URL: l.URL, FaviconURL: l.FaviconURL, Category: catName[l.CategoryID]})

	}

	web.Render(a.Templates, w, "admin.html", adminPageData{Success: r.URL.Query().Get("success"), Error: r.URL.Query().Get("error"), Categories: cats, Links: rows}, a.Log)

}

func (a *App) adminAddCategory(w http.ResponseWriter, r *http.Request) {

	if err := r.ParseForm(); err != nil {

		web.RedirectWithError(w, r, "/admin", "Bad request")

		return

	}

	name := strings.TrimSpace(r.FormValue("name"))

	if name == "" {

		web.RedirectWithError(w, r, "/admin", "Name required")

		return

	}

	if _, err := createCategory(a.DB, name); err != nil {

		a.Log.Error("create category", "err", err)

		web.RedirectWithError(w, r, "/admin", "Failed to add category")

		return

	}

	web.RedirectWithSuccess(w, r, "/admin", "Category added")

}

func (a *App) adminDeleteCategory(w http.ResponseWriter, r *http.Request) {

	_, _ = deleteCategoryByShortID(a.DB, r.PathValue("short_id"))

	web.RedirectWithSuccess(w, r, "/admin", "Category removed")

}

func (a *App) adminMoveCategory(w http.ResponseWriter, r *http.Request) {

	dir := 0

	switch r.PathValue("dir") {

	case "up":

		dir = -1

	case "down":

		dir = 1

	default:

		web.RedirectWithError(w, r, "/admin", "Invalid direction")

		return

	}

	if _, err := moveCategory(a.DB, r.PathValue("short_id"), dir); err != nil {

		a.Log.Error("move category", "err", err)

		web.RedirectWithError(w, r, "/admin", "Failed to reorder")

		return

	}

	web.RedirectWithSuccess(w, r, "/admin", "Category reordered")

}

func (a *App) adminAddLink(w http.ResponseWriter, r *http.Request) {

	if err := r.ParseForm(); err != nil {

		web.RedirectWithError(w, r, "/admin", "Bad request")

		return

	}

	title := strings.TrimSpace(r.FormValue("title"))

	url := strings.TrimSpace(r.FormValue("url"))

	if title == "" || url == "" {

		web.RedirectWithError(w, r, "/admin", "Title and URL required")

		return

	}

	cat, err := getCategoryByName(a.DB, r.FormValue("category"))

	if err != nil || cat == nil {

		web.RedirectWithError(w, r, "/admin", "Unknown category")

		return

	}

	link, err := createLink(a.DB, title, url, nil, cat.ID)

	if err != nil {

		a.Log.Error("create link", "err", err)

		web.RedirectWithError(w, r, "/admin", "Failed to add link")

		return

	}

	go func(id int64, u string) {

		if fav := discoverFavicon(context.Background(), u); fav != "" {

			if err := updateLinkFavicon(a.DB, id, &fav); err != nil {

				a.Log.Error("update favicon", "err", err)

			}

		}

	}(link.ID, url)

	web.RedirectWithSuccess(w, r, "/admin", "Link added")

}

func (a *App) adminDeleteLink(w http.ResponseWriter, r *http.Request) {

	_, _ = deleteLinkByShortID(a.DB, r.PathValue("short_id"))

	web.RedirectWithSuccess(w, r, "/admin", "Link removed")

}

package main

import (

	"context"

	"html/template"

	"log"

	"log/slog"

	"net/http"

	"os"

	"time"

	"github.com/stevedylandev/andromeda/crates-go/auth"

	"github.com/stevedylandev/andromeda/crates-go/config"

)

func main() {

	config.LoadDotEnv(".env")

	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))

	dbPath := config.Getenv("BOOKMARKS_DB_PATH", "bookmarks.sqlite")

	db, err := openDB(dbPath)

	if err != nil {

		log.Fatal(err)

	}

	defer db.Close()

	sessions := &auth.Store{DB: db, CookieName: "session", CookieSecure: config.GetenvBool("COOKIE_SECURE", false)}

	if err := sessions.EnsureSchema(); err != nil {

		log.Fatal(err)

	}

	sessions.PruneExpired()

	tmpl := template.Must(template.ParseFS(appFS, "templates/*.html"))

	app := &App{

		DB:           db,

		Log:          logger,

		Templates:    tmpl,

		Sessions:     sessions,

		Password:     os.Getenv("BOOKMARKS_PASSWORD"),

		APIKey:       os.Getenv("BOOKMARKS_API_KEY"),

		CookieSecure: sessions.CookieSecure,

	}

	go app.faviconBackfill(context.Background())

	addr := config.Getenv("HOST", "127.0.0.1") + ":" + config.Getenv("PORT", "3000")

	logger.Info("bookmarks-go server running", "addr", addr)

	if err := http.ListenAndServe(addr, app.routes()); err != nil {

		log.Fatal(err)

	}

}

func (a *App) faviconBackfill(ctx context.Context) {

	pending, err := listLinksMissingFavicon(a.DB)

	if err != nil {

		a.Log.Error("favicon backfill query", "err", err)

		return

	}

	if len(pending) == 0 {

		return

	}

	a.Log.Info("favicon backfill", "count", len(pending))

	for _, row := range pending {

		if fav := discoverFavicon(ctx, row.URL); fav != "" {

			if err := updateLinkFavicon(a.DB, row.ID, &fav); err != nil {

				a.Log.Error("favicon backfill update", "id", row.ID, "err", err)

			}

		}

		time.Sleep(250 * time.Millisecond)

	}

	a.Log.Info("favicon backfill done")

}

package main

import (

	"net/http"

	"github.com/stevedylandev/andromeda/crates-go/auth"

	"github.com/stevedylandev/andromeda/crates-go/darkmatter"

	"github.com/stevedylandev/andromeda/crates-go/web"

)

func (a *App) routes() *http.ServeMux {

	mux := http.NewServeMux()

	requireSession := func(next http.HandlerFunc) http.HandlerFunc {

		return a.Sessions.RequireSession("/login", next)

	}

	requireAPIKey := func(next http.HandlerFunc) http.HandlerFunc {

		return auth.RequireAPIKey(a.APIKey, next)

	}

	mux.HandleFunc("GET /", a.indexHandler)

	mux.HandleFunc("GET /login", a.loginGetHandler)

	mux.HandleFunc("POST /login", a.loginPostHandler)

	mux.HandleFunc("GET /logout", a.logoutHandler)

	mux.HandleFunc("GET /admin", requireSession(a.adminHandler))

	mux.HandleFunc("POST /admin/categories", requireSession(a.adminAddCategory))

	mux.HandleFunc("POST /admin/categories/{short_id}/delete", requireSession(a.adminDeleteCategory))

	mux.HandleFunc("POST /admin/categories/{short_id}/move/{dir}", requireSession(a.adminMoveCategory))

	mux.HandleFunc("POST /admin/links", requireSession(a.adminAddLink))

	mux.HandleFunc("POST /admin/links/{short_id}/delete", requireSession(a.adminDeleteLink))

	mux.HandleFunc("GET /api/categories", a.apiListCategories)

	mux.HandleFunc("GET /api/links", a.apiListLinks)

	mux.HandleFunc("POST /api/links", requireAPIKey(a.apiCreateLink))

	mux.HandleFunc("GET /static/", web.EmbeddedHandler(appFS, "static"))

	darkmatter.Mount(mux, "/assets")

	return mux

}

{"name":"","short_name":"","icons":[{"src":"/android-chrome-192x192.png","sizes":"192x192","type":"image/png"},{"src":"/android-chrome-512x512.png","sizes":"512x512","type":"image/png"}],"theme_color":"#ffffff","background_color":"#ffffff","display":"standalone"}

/* feeds — app-specific styles.

 * Shared reset / tokens / components come from /assets/darkmatter.css.

 */

/* The logo wraps an h1 in feeds markup. */

.logo h1 {

  font-size: 28px;

  font-weight: 700;

  text-transform: uppercase;

}

.about {

  display: flex;

  flex-direction: column;

  gap: 0.5rem;

  font-size: 14px;

  line-height: 1.25rem;

}

/* Feeds list */

.feeds-list {

  width: 100%;

  display: flex;

  flex-direction: column;

  gap: 1.5rem;

}

.feed-item {

  display: flex;

  flex-direction: column;

  gap: 0.5rem;

  padding: 1rem 0;

  border-bottom: 1px solid #333;

}

.feed-item:last-child {

  border-bottom: none;

}

.feed-meta {

  display: flex;

  justify-content: space-between;

  align-items: center;

  font-size: 12px;

  opacity: 0.5;

}

.feed-source {

  font-weight: 700;

}

.feed-title {

  font-size: 16px;

  font-weight: 400;

  line-height: 1.4;

}

.feed-title a {

  text-decoration: none;

}

.feed-author {

  font-size: 12px;

  opacity: 0.5;

  font-style: italic;

}

#feed-urls {

  font-size: 12px;

  opacity: 0.5;

}

.no-feeds,

#loading {

  text-align: center;

  opacity: 0.5;

  padding: 2rem;

}

#error {

  text-align: center;

  padding: 2rem;

}

/* Admin forms */

.admin-form {

  display: flex;

  flex-direction: column;

  gap: 0.75rem;

  width: 100%;

}

.admin-form h3 {

  font-size: 14px;

  font-weight: 400;

  opacity: 0.5;

}

.admin-notice,

.hint {

  font-size: 12px;

  opacity: 0.5;

  line-height: 1.4;

}

/* Discover panel */

.discover-row {

  display: flex;

  gap: 0.5rem;

  width: 100%;

}

.discover-row input {

  flex: 1;

}

.discover-status {

  font-size: 12px;

}

.discover-results {

  display: flex;

  flex-direction: column;

  gap: 0.25rem;

  width: 100%;

}

.discover-result-item {

  background: #121113;

  color: #ffffff;

  border: 1px solid #333;

  padding: 8px 10px;

  font-size: 12px;

  text-align: left;