git.stevedylan.dev

chore: finished docs updates b0d543ca

Steve · 2026-04-10 21:40 13 file(s) · +279 −426

docs/docs/pages/apps/cellar.mdx +31 −62

# Cellar
#
![demo of cellar](https://files.stevedylan.dev/cellar-demo.png)

A minimal wine collection tracker

## Overview
![demo of cellar](https://files.stevedylan.dev/cellar-demo.png)

A simple, self-hosted wine collection app built with Rust.


- Dark themed UI with Commit Mono font
- SQLite for persistent storage

## Quickstart

```bash
git clone https://github.com/stevedylandev/cellar.git
cd cellar
cp .env.example .env
# Edit .env with your password and Anthropic API key
cargo build --release
./target/release/cellar
```
## Configure

### Environment Variables


| `PORT` | Server port | `3000` |
| `COOKIE_SECURE` | Enable HTTPS-only cookies | `false` |

## Routes
The `ANTHROPIC_API_KEY` is optional but required for AI-powered tasting notes and image analysis.

### Public
## Deploy

| Method | Route | Description |
|---|---|---|
| `GET` | `/` | Wine collection list |
| `GET` | `/wines/{short_id}` | Wine detail page |
| `GET` | `/wines/{short_id}/image` | Wine image |
### Railway

### Admin

All admin routes (except login) require an authenticated session.

| Method | Route | Description |
|---|---|---|
| `GET/POST` | `/admin/login` | Login page |
| `GET` | `/admin/logout` | Logout |
| `GET` | `/admin` | Admin dashboard |
| `GET/POST` | `/admin/new` | Add a new wine |
| `GET/POST` | `/admin/edit/{short_id}` | Edit a wine |
| `POST` | `/admin/delete/{short_id}` | Delete a wine |
| `POST` | `/admin/analyze-image` | AI image analysis via Claude |

## Structure

```
cellar/
├── src/
│   ├── main.rs        # App entrypoint, env vars, starts server
│   ├── server.rs      # Axum router, HTTP handlers, and templates
│   ├── auth.rs        # Password verification and session management
│   ├── claude.rs      # Anthropic API integration for tasting notes
│   └── db.rs          # SQLite database layer (wines, sessions)
├── templates/         # Askama HTML templates
│   ├── base.html      # Base layout with header and nav
│   ├── login.html     # Login page
│   ├── index.html     # Wine collection list
│   ├── wine.html      # Single wine display
│   ├── wine_form.html # Add/edit wine form
│   └── admin.html     # Admin page
├── static/            # Favicons, og:image, styles, and webmanifest
├── Dockerfile         # Multi-stage build (Rust + Debian slim)
└── docker-compose.yml
```

## Deployment

### Railway
The easiest way to deploy Cellar is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. Cellar requires `CELLAR_PASSWORD` during the configure step, and optionally `ANTHROPIC_API_KEY` if you want AI-powered tasting notes and image analysis.

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/MNprVh?referralCode=JGcIp6)



### Binary

Install with Homebrew:

```bash
cargo build --release
brew install stevedylandev/tap/cellar
```

Or grab a prebuilt binary from the [releases page](https://github.com/stevedylandev/andromeda/releases?q=cellar&expanded=true).

You can also build from source:

```bash
cargo build --release -p cellar
```

The resulting binary at `./target/release/cellar` is self-contained with all assets embedded. Copy it to your server with a configured `.env` file and run it directly.

## Use

Your wine collection is publicly viewable at `/` with individual wine pages at `/wines/{short_id}`.

### Admin

Log in at `/admin/login` with your configured password to access the admin pages.

| Page | Description |
|---|---|
| `/admin` | Admin dashboard listing every wine in your collection |
| `/admin/new` | Add a new wine, optionally using AI image analysis to prefill details |
| `/admin/edit/{short_id}` | Edit an existing wine |

docs/docs/pages/apps/feeds.mdx +48 −51

#
![demo of feeds](https://files.stevedylan.dev/feeds-demo.png)

Minimal RSS Feeds

## Overview

Feeds is a minimal RSS reader that mimics the original experience of RSS. It's just a list of posts. No categories, no marking a post read or unread, and there is no in-app reading. With this approach you have to read the post on the author's personal website and experience it in its original context.

- Single Rust binary with embedded assets

- Feeds API with JSON and OPML export
- Dark themed UI with Commit Mono font

## Quickstart

```bash
git clone https://github.com/stevedylandev/andromeda.git
cd andromeda
cargo run -p feeds
# Server running on http://localhost:3000
```
## Configure

### Environment Variables

| Variable | Description | Default |
|---|---|---|
| `DEFAULT_FEED` | Comma-separated list of RSS feed URLs to load when no `?url=` or `?urls=` query param is provided | -- |
| `FRESHRSS_URL` | URL of your FreshRSS instance | -- |
| `FRESHRSS_USERNAME` | FreshRSS username | -- |
| `FRESHRSS_PASSWORD` | FreshRSS password | -- |
| `ADMIN_PASSWORD` | Password for the admin panel | -- |
| `COOKIE_SECURE` | Enable HTTPS-only cookies | `false` |

## Usage
The FreshRSS credentials are only needed if you want to source feeds from a FreshRSS instance.

## Deploy

### Railway

The easiest way to deploy Feeds is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. Feeds requires `ADMIN_PASSWORD` to enable the admin panel, and optionally the `FRESHRSS_*` variables if you want to source feeds from a FreshRSS instance.

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/Ezvmhx?referralCode=JGcIp6)

### Docker

```bash
cd apps/feeds
cp .env.sample .env
# Edit .env with your credentials
docker compose up -d
```

### Binary

Install with Homebrew:

```bash
brew install stevedylandev/tap/feeds
```

Or grab a prebuilt binary from the [releases page](https://github.com/stevedylandev/andromeda/releases?q=feeds&expanded=true).

You can also build from source:

```bash
cargo build --release -p feeds
```

The resulting binary is self-contained with all assets embedded. Copy it to your server with a configured `.env` file and run it directly.

## Use

There are several built-in ways to source RSS feeds.



```
?urls=https://bearblog.dev/discover/feed/,https://bearblog.stevedylan.dev/feed/
```

### Default Feed

Set the `DEFAULT_FEED` environment variable to a comma-separated list of feed URLs and the app will load them whenever no `?url=` or `?urls=` query param is provided:

```
DEFAULT_FEED=https://bearblog.dev/discover/feed/,https://bearblog.stevedylan.dev/feed/
```

### OPML File

/feeds?format=json
/feeds?format=opml
```

## Structure

```
feeds/
├── src/
│   ├── main.rs        # Axum server with routing, templates, and static asset serving
│   ├── feeds.rs       # Feed fetching, OPML parsing, and FreshRSS API integration
│   ├── auth.rs        # Session-based authentication with constant-time password verification
│   └── models.rs      # Data structures for feeds and FreshRSS responses
├── templates/         # Askama HTML templates
├── assets/            # Static assets embedded at compile time via rust-embed
├── Dockerfile
└── docker-compose.yml
```

## Deployment

### Railway

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/Ezvmhx?referralCode=JGcIp6)

### Docker

```bash
cd apps/feeds
cp .env.sample .env
# Edit .env with your credentials
docker compose up -d
```

### Binary

```bash
cargo build --release -p feeds
```

The resulting binary is self-contained with all assets embedded. Copy it to your server with a configured `.env` file and run it directly.

docs/docs/pages/apps/jotts.mdx +18 −36


![demo of jotts](https://files.stevedylan.dev/jotts-demo.png)

A minimal notes app

## Overview

A simple, self-hosted markdown note app built with Rust.

- Single ~7MB Rust binary with embedded assets

- Dark themed UI with Commit Mono font
- SQLite for persistent storage

## Quickstart

```bash
git clone https://github.com/stevedylandev/andromeda.git
cd andromeda
cp apps/jotts/.env.example .env
# Edit .env with your password
cargo run -p jotts
```
## Configure

### Environment Variables


| `PORT` | Server port | `3000` |
| `COOKIE_SECURE` | Enable HTTPS-only cookies | `false` |

## Structure

```
jotts/
├── src/
│   ├── main.rs        # App entrypoint, env vars, starts server
│   ├── server.rs      # Axum router, HTTP handlers, and templates
│   ├── auth.rs        # Password verification and session management
│   └── db.rs          # SQLite database layer (notes, sessions)
├── templates/         # Askama HTML templates
│   ├── base.html      # Base layout with header and nav
│   ├── login.html     # Login page
│   ├── index.html     # Note list
│   ├── view.html      # Single note display
│   ├── new.html       # Create note form
│   └── edit.html      # Edit note form
├── static/            # Favicons, og:image, styles, and webmanifest
├── assets/            # Commit Mono font files
├── Dockerfile
└── docker-compose.yml
```
## Deploy

## Deployment
### Railway

### Railway
The easiest way to deploy Jotts is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. Jotts requires `JOTTS_PASSWORD` to be set during the configure step.

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/DLhUhH?referralCode=JGcIp6)



### Binary

Install with Homebrew:

```bash
brew install stevedylandev/tap/jotts
```

Or grab a prebuilt binary from the [releases page](https://github.com/stevedylandev/andromeda/releases?q=jotts&expanded=true).

You can also build from source:

```bash
cargo build --release -p jotts
```

The resulting binary is self-contained with all assets embedded. Copy it to your server with a configured `.env` file and run it directly.

## Use

Log in at `/login` with your configured password. From there you can create, edit, and delete markdown notes. Notes support GitHub-flavored markdown including strikethrough, tables, and task lists.

docs/docs/pages/apps/og.mdx +18 −29


![demo of og](https://files.stevedylan.dev/og-demo.png)

A simple web tool for inspecting Open Graph tags on any URL.

## Overview

A self-hosted Open Graph tag inspector built with Rust. Enter any URL and instantly see its OG metadata.

- Single Rust binary with embedded assets

- Dark themed UI with Commit Mono font
- No database needed -- fully stateless

## Quickstart

```bash
git clone https://github.com/stevedylandev/andromeda.git
cd andromeda
cargo run -p og
```
## Configure

### Environment Variables


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

## Structure
## Deploy

```
og/
├── src/
│   ├── main.rs        # Entry point and server startup
│   ├── server.rs      # Axum routes and request handling
│   └── og.rs          # Open Graph tag fetching and parsing
├── templates/         # Askama HTML templates
│   ├── base.html      # Base layout
│   ├── index.html     # Search form
│   └── results.html   # OG tag results display
├── static/            # Fonts, favicons, and styles
├── Dockerfile
└── docker-compose.yml
```
### Railway

## Deployment

### Railway
The easiest way to deploy OG is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. OG is fully stateless and needs no environment variables beyond the defaults.

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/OdXBt_?referralCode=JGcIp6)



### Binary

Install with Homebrew:

```bash
brew install stevedylandev/tap/og
```

Or grab a prebuilt binary from the [releases page](https://github.com/stevedylandev/andromeda/releases?q=og&expanded=true).

You can also build from source:

```bash
cargo build --release -p og
```

The resulting binary is self-contained with all assets embedded. Copy it to your server and run it directly.

## Use

Enter any URL to inspect its Open Graph tags including title, description, and image. Results are displayed instantly with no account or configuration needed.

docs/docs/pages/apps/parcels.mdx +18 −33


![demo of parcels](https://files.stevedylan.dev/parcels-demo.png)

A minimal package tracking app

:::warning
This app originally used USPS, but starting April 1st 2026, it has become much harder to obtain/maintain API keys.
:::

## Overview

A self-hosted package tracker for USPS. Track your packages without logging into USPS every time.


- Track USPS packages with custom labels
- Delete packages you no longer want to track

## Quickstart

```bash
git clone https://github.com/stevedylandev/andromeda.git
cd andromeda
cp apps/parcels/.env.example .env
# Edit .env with your USPS API credentials and app password
cargo run -p parcels
```
## Configure

You'll need a [USPS Web Tools API](https://developer.usps.com) account to get your `USPS_CLIENT_ID` and `USPS_CLIENT_SECRET`.


| `PORT` | Server port | `3000` |
| `COOKIE_SECURE` | Enable HTTPS-only cookies | `false` |

## Structure
## Deploy

```
parcels/
├── src/
│   ├── main.rs        # Axum web server, routes, and app state
│   ├── auth.rs        # Password verification and session management
│   ├── db.rs          # SQLite database layer (packages, events, sessions)
│   └── usps.rs        # USPS API integration with OAuth2 token caching
├── templates/         # Askama HTML templates
│   ├── base.html      # Base layout
│   ├── index.html     # Package list
│   ├── detail.html    # Package detail with tracking events
│   ├── add.html       # Add package form
│   └── login.html     # Login page
├── static/            # Fonts, favicons, and images
├── Dockerfile
└── docker-compose.yml
```
### Railway

## Deployment

### Railway
The easiest way to deploy Parcels is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. Parcels requires `APP_PASSWORD`, `USPS_CLIENT_ID`, and `USPS_CLIENT_SECRET` to be set during the configure step.

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/HNQUs4?referralCode=JGcIp6)


This will start Parcels on port `3000` with a persistent volume for the SQLite database.

### Binary

Install with Homebrew:

```bash
brew install stevedylandev/tap/parcels
```

Or grab a prebuilt binary from the [releases page](https://github.com/stevedylandev/andromeda/releases?q=parcels&expanded=true).

You can also build from source:

```bash
cargo build --release -p parcels
```

The resulting binary is self-contained (~7MB). Copy it to your server with a configured `.env` file and run it directly.

## Use

Log in with your configured password, then add packages by entering a USPS tracking number and an optional label. Your packages and their tracking events are displayed on the main page. Delete packages you no longer need to track.

docs/docs/pages/apps/posts.mdx +18 −43


![demo of posts](https://assets.andromeda.build/posts-demo.png)

A minimal CMS blog with admin interface

## Overview

A self-hosted blog CMS built with Rust.

- Single Rust binary with embedded assets

- Dark themed UI with Commit Mono font
- SQLite for persistent storage

## Quickstart

```bash
git clone https://github.com/stevedylandev/andromeda.git
cd andromeda
cp apps/posts/.env.example .env
# Edit .env with your password
cargo run -p posts
```
## Configure

### Environment Variables


| `PORT` | Server port | `3000` |
| `COOKIE_SECURE` | Enable HTTPS-only cookies | `false` |

## Structure
## Deploy

```
posts/
├── src/
│   ├── main.rs        # App entrypoint, env vars, starts server
│   ├── server.rs      # Axum router, HTTP handlers, and templates
│   ├── auth.rs        # Password verification and session management
│   └── db.rs          # SQLite database layer (posts, pages, files, settings, sessions)
├── templates/         # Askama HTML templates
│   ├── base.html            # Public base layout
│   ├── index.html           # Blog home page
│   ├── post.html            # Single post view
│   ├── posts.html           # Post listing
│   ├── page.html            # Static page view
│   ├── login.html           # Login page
│   ├── admin_base.html      # Admin layout
│   ├── admin_index.html     # Admin dashboard
│   ├── admin_post_form.html # Create/edit post form
│   ├── admin_pages.html     # Admin page listing
│   ├── admin_page_form.html # Create/edit page form
│   ├── admin_files.html     # File upload management
│   └── admin_settings.html  # Blog settings
├── static/            # Favicons, fonts, and styles
├── uploads/           # Uploaded files directory
├── Dockerfile
└── docker-compose.yml
```
### Railway

## Deployment

### Railway
The easiest way to deploy Posts is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. Posts requires `POSTS_PASSWORD` and `SITE_URL` to be set during the configure step.

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/tYtJYp?referralCode=JGcIp6)



### Binary

Install with Homebrew:

```bash
brew install stevedylandev/tap/posts
```

Or grab a prebuilt binary from the [releases page](https://github.com/stevedylandev/andromeda/releases?q=posts&expanded=true).

You can also build from source:

```bash
cargo build --release -p posts
```

The resulting binary is self-contained with all assets embedded. Copy it to your server with a configured `.env` file and run it directly.

## Use

Log in at `/login` with your configured password to access the admin panel. From there you can manage blog posts, static pages, file uploads, and site settings including custom CSS. Your blog's RSS feed is available at `/feed.xml`.

docs/docs/pages/apps/shrink.mdx +18 −26


![demo of shrink](https://files.stevedylan.dev/shrink-demo.png)

A minimal image compression app

## Overview

A simple self-hosted tool for compressing and resizing images. Upload an image, set your desired quality and optional width, and download the compressed JPEG.

- Single Rust binary

- Optional resize by width (preserves aspect ratio)
- 20MB upload limit

## Quickstart

```bash
git clone https://github.com/stevedylandev/andromeda.git
cd andromeda
cargo run -p shrink
```
## Configure

### Environment Variables


| `HOST` | Server bind host | `127.0.0.1` |
| `PORT` | Server bind port | `3000` |

## Structure

```
shrink/
├── src/
│   ├── main.rs        # Entry point and server startup
│   └── server.rs      # Axum routes and image compression logic
├── templates/
│   └── index.html     # Upload UI
├── static/            # Fonts and static assets
├── Dockerfile
└── docker-compose.yml
```

## Deployment
## Deploy

### Railway

The easiest way to deploy Shrink is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. Shrink needs no environment variables beyond the defaults.

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/enYUFb?referralCode=JGcIp6)



### Binary

Install with Homebrew:

```bash
brew install stevedylandev/tap/shrink
```

Or grab a prebuilt binary from the [releases page](https://github.com/stevedylandev/andromeda/releases?q=shrink&expanded=true).

You can also build from source:

```bash
cargo build --release -p shrink
```

The resulting binary is self-contained. Copy it to your server and run it directly.

## Use

Upload an image, set your desired quality (1-100) and an optional target width, then download the compressed JPEG. Aspect ratio is preserved when resizing.

docs/docs/pages/apps/sipp.mdx +45 −83


![demo of sipp](https://files.stevedylan.dev/sipp-demo.png)

Minimal code sharing

## Overview

A single binary for code sharing with a web server and interactive TUI.

- Create snippets and share on the web

A small demo instance runs at [sipp.so](https://sipp.so). All snippets created there are public and might be deleted at any time; host your own instance with your own API key for personal use!
:::

## Quickstart
## Install

Sipp can be installed several ways:

### Homebrew

```bash
cargo install sipp-so
sipp --help
brew install stevedylandev/tap/sipp-so
```

Start a server and create a snippet:
### Cargo

```bash
sipp server --port 3000
cargo install sipp-so
```

```bash
# Path to file
sipp path/to/file.rs
### Releases

# Or use the interactive TUI
sipp
```
Visit the [releases](https://github.com/stevedylandev/sipp/releases) page for binaries and install scripts.

### Install
## Configure

Sipp can be installed several ways:
### Environment Variables

#### Homebrew
| Variable | Description |
|---|---|
| `SIPP_API_KEY` | API key for protecting endpoints |
| `SIPP_AUTH_ENDPOINTS` | Comma-separated list of endpoints requiring auth: `api_list`, `api_create`, `api_get`, `api_delete`, `all`, or `none` (defaults to `api_delete,api_list`) |
| `SIPP_MAX_CONTENT_SIZE` | Maximum snippet content size in bytes (defaults to `512000` / 500 KB) |
| `SIPP_DB_PATH` | Custom path for the SQLite database file (defaults to `sipp.sqlite`) |

## Deploy

### Railway

The easiest way to deploy a Sipp server is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. Set `SIPP_API_KEY` during the configure step to protect your authenticated endpoints.

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/Axcf_D?referralCode=JGcIp6)

### Docker

```bash
brew install stevedylandev/tap/sipp-so
SIPP_API_KEY=your-secret-key docker compose up -d
```

#### Cargo
### Binary

```bash
cargo install sipp-so
cargo build --release -p sipp
```

#### Releases
The resulting binary is self-contained with all assets embedded. Copy it to your server with your environment variables configured and run it directly.

Visit the [releases](https://github.com/stevedylandev/sipp/releases) page for binaries and install scripts.
## Use

## CLI
### CLI

```
sipp [OPTIONS] [FILE] [COMMAND]
```

### Commands
#### Commands

| Command | Description |
|---|---|

| `tui` | Launch the interactive TUI |
| `auth` | Save remote URL and API key to config file |

### Arguments
#### Arguments

| Argument | Description |
|---|---|
| `[FILE]` | File path to create a snippet from |

### Options
#### Options

| Option | Description |
|---|---|
| `-r, --remote <URL>` | Remote server URL (env: `SIPP_REMOTE_URL`) |
| `-k, --api-key <KEY>` | API key for authenticated operations (env: `SIPP_API_KEY`) |

## Server
### Server

Sipp includes a built-in web server powered by Axum. Start it with:
Start the web server with:

```bash
sipp server --port 3000 --host localhost
```

### Environment Variables

| Variable | Description |
|---|---|
| `SIPP_API_KEY` | API key for protecting endpoints |
| `SIPP_AUTH_ENDPOINTS` | Comma-separated list of endpoints requiring auth: `api_list`, `api_create`, `api_get`, `api_delete`, `all`, or `none` (defaults to `api_delete,api_list`) |
| `SIPP_MAX_CONTENT_SIZE` | Maximum snippet content size in bytes (defaults to `512000` / 500 KB) |
| `SIPP_DB_PATH` | Custom path for the SQLite database file (defaults to `sipp.sqlite`) |

### API Endpoints
#### API Endpoints

| Method | Endpoint | Description |
|---|---|---|


Authenticated endpoints require an `x-api-key` header.

### Raw Output for CLI Tools
#### Raw Output for CLI Tools

When you access a snippet URL (`/s/{short_id}`) with `curl`, `wget`, or `httpie`, the server returns the raw content as plain text instead of HTML:


curl https://sipp.so/s/abc123
```

## TUI
### TUI

The Sipp TUI makes it easy to create, copy, share, and manage your snippets either locally or remotely.


sipp -r https://sipp.so -k your-api-key
```

### Local Access
#### Local Access

If you are running `sipp` in the same directory as the `sipp.sqlite` file created by the server instance, the TUI will automatically access the database locally.

### Remote Access
#### Remote Access

To access a remote instance:
- Set the `SIPP_API_KEY` variable in your server instance
- Run `sipp auth` to enter your server URL and API key, stored under `$HOME/.config/sipp`

### Keybindings
#### Keybindings

| Key | Action |
|---|---|

| `r` | Refresh snippets (remote only) |
| `q` | Quit |
| `?` | Toggle help |

## Structure

```
sipp/
├── src/
│   ├── main.rs        # CLI argument parsing and entry point
│   ├── lib.rs         # Library exports
│   ├── server.rs      # Axum web server, routes, and templates
│   ├── tui.rs         # Interactive terminal UI
│   ├── db.rs          # SQLite database layer
│   ├── backend.rs     # Local/remote backend abstraction
│   ├── config.rs      # Config file management
│   └── highlight.rs   # Syntax highlighting with custom themes
├── templates/         # Askama HTML templates
├── static/            # Fonts, favicons, and styles
├── Dockerfile
└── docker-compose.yml
```

## Deployment

### Railway

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/Axcf_D?referralCode=JGcIp6)

### Docker

```bash
SIPP_API_KEY=your-secret-key docker compose up -d
```

### Binary

```bash
cargo build --release -p sipp
```

The resulting binary is self-contained with all assets embedded. Copy it to your server with your environment variables configured and run it directly.

docs/docs/pages/deploy-railway.mdx (added) +46 −0

1	+	# Deploying with Railway
2	+
3	+	[Railway](https://railway.com) is halfway between a VPS (virtual private server) and a hosting platform like Netlify or Vercel. It's the perfect place to host an Andromeda app if you're a beginner, and every Andromeda app has a one-click Railway template to make it even easier.
4	+
5	+	This guide walks through the general process of deploying the Andromeda app [posts](/apps/posts) to Railway. For app-specific environment variables and configuration, check the corresponding app's page.
6	+
7	+	::::steps
8	+	### Deploy
9	+
10	+	On the app's page, click the `Deploy on Railway` button. If you haven't signed up for Railway yet you'll be prompted to do so before continuing.
11	+
12	+	### Configure
13	+
14	+	Railway will show a `Configure` button, and when you click on it you will need to fill in the environment variables for that app. Most Andromeda apps share a couple of common ones:
15	+
16	+	- `SITE_URL` - The public URL your app will be hosted at. If you don't know what that URL will be yet, you can put a placeholder like `https://example.com` and update it once Railway gives you a hosted URL.
17	+	- A password variable (e.g. `POSTS_PASSWORD`, `JOTTS_PASSWORD`, `CELLAR_PASSWORD`) - The password used to access the admin dashboard for that app.
18	+
19	+	Check the specific app's page for the full list of environment variables it accepts.
20	+
21	+	![railway deploying app](https://assets.andromeda.build/docs/railway-deploy-app_compressed.jpg)
22	+
23	+	Once you have filled these out click the `Save Config` button at the bottom, then click `Deploy`.
24	+
25	+	### Use
26	+
27	+	Your app is now live. Click on the square with your app to see the hosted URL for it.
28	+
29	+	![railway deployment with hosted url](https://assets.andromeda.build/docs/railway-deployment.png)
30	+
31	+	If your app uses a `SITE_URL` variable, copy the hosted URL, go into the `Variables` tab, click `Edit` for the `SITE_URL` variable, and paste in the new value. This makes sure the app is fully functional.
32	+
33	+	![railway edit existing variable](https://assets.andromeda.build/docs/railway-edit-variable.png)
34	+
35	+	Those Railway URLs are not pretty, so if you have a custom domain, visit the `Settings` tab and under the `Networking` section click `+ Custom Domain` to set it up. Make sure to update the `SITE_URL` variable again after you do this.
36	+	::::
37	+
38	+	Check out the other available Andromeda apps! Each one has its own one-click Railway template on its page, along with the full list of environment variables it accepts.
39	+
40	+	- [Posts](/apps/posts) - A minimal CMS blog with an admin interface.
41	+	- [Jotts](/apps/jotts) - A minimal self-hosted markdown notes app.
42	+	- [Cellar](/apps/cellar) - A minimal wine collection tracker.
43	+	- [Feeds](/apps/feeds) - A minimal RSS reader that sends you back to the author's site to read posts in their original context.
44	+	- [Shrink](/apps/shrink) - A simple self-hosted tool for compressing and resizing images.
45	+	- [Sipp](/apps/sipp) - A single binary for code sharing with a web server and interactive TUI.
46	+	- [OG](/apps/og) - A simple web tool for inspecting Open Graph tags on any URL.

docs/docs/pages/diy/skills.mdx +11 −59

# Skills

Andromeda apps are scaffolded using [Claude Code](https://claude.ai/code) with a custom skill called `rust-crud`. This page explains how to use it to build your own apps in the same style.
Andromeda ships with two [Claude Code](https://claude.ai/code) skills that make it easy to build new apps in the same style. Both live in the repo at [`skills/`](https://github.com/stevedylandev/andromeda/tree/main/skills).

## What is rust-crud?
## andromeda-stack

`rust-crud` is a Claude Code skill that scaffolds a complete Rust CRUD web application matching the Andromeda stack:
[`andromeda-stack`](https://github.com/stevedylandev/andromeda/blob/main/skills/andromeda-stack/SKILL.md) scaffolds a complete Rust CRUD web app matching the Andromeda stack:

- Axum web server with routing
- SQLite database with rusqlite
- Askama HTML templates
- API key authentication
- `andromeda-auth` for session or API key auth
- Embedded static assets via rust-embed
- Dockerfile and docker-compose.yml for deployment

## Using the Skill
New apps land under `apps/` in the workspace and share dependencies via the root `Cargo.toml`.

In Claude Code, invoke the skill when you want to create a new app:
## darkmatter-styles

```
/rust-crud
```
[`darkmatter-styles`](https://github.com/stevedylandev/andromeda/tree/main/skills/darkmatter-styles/SKILL.md) applies the shared Andromeda aesthetic: dark background, white borders, Commit Mono, minimal layout, no frameworks. Use it when building new pages or components that need to match the rest of the lineup.

Describe what you want to build and the skill will generate a complete, working app that follows the same patterns as every other Andromeda app.
## Installing

## Building Your Own App

If you want to add a new app to the workspace manually, follow these steps:

### 1. Create the app directory
Use [`npx skills add`](https://github.com/vercel-labs/skills) to pull either skill directly from the repo:

```bash
mkdir -p apps/my-app/src
mkdir -p apps/my-app/templates
mkdir -p apps/my-app/static
```

### 2. Add to workspace

Add your app to the root `Cargo.toml` workspace members:

```toml
[workspace]
members = [
    "apps/my-app",
    # ...existing apps
]
npx skills add stevedylandev/andromeda/skills
```

### 3. Set up Cargo.toml

```toml
[package]
name = "my-app"
version = "0.1.0"
edition = "2021"

[dependencies]
axum = "0.8"
tokio = { version = "1", features = ["full"] }
rusqlite = { version = "0.32", features = ["bundled"] }
askama = "0.12"
askama_axum = "0.4"
rust-embed = "8"
tower-http = { version = "0.6", features = ["cors"] }
serde = { version = "1", features = ["derive"] }
dotenvy = "0.15"
```

### 4. Follow the pattern

Use the [Stack](/diy/stack) page as a reference for how to structure your `main.rs`, `server.rs`, and `db.rs` files. Look at any existing app in `apps/` for a working example.

### 5. Build and run

```bash
cargo run -p my-app
```
Once installed, invoke them in Claude Code by describing what you want to build — the skills trigger automatically based on their descriptions.

docs/docs/public/icon.png +0 −0

Binary file — no preview.

docs/vocs.config.ts +6 −2

  markdown: {
    code: {
      themes: {
        light: "min-light",
        dark: "slack-dark",
        light: "github-light-default",
        dark: "github-dark-default",
      },
    },
  },

        {
          text: 'What is Andromeda',
          link: '/what-is-andromeda',
        },
        {
          text: 'Deploying with Railway',
          link: '/deploy-railway',
        },
      ],
    },

skills/darkmatter-styles/SKILL.md +2 −2

---
name: darkmatter-styles
description: Use when building any web UI for Steve - applies his personal dark aesthetic with Commit Mono font, #121113 background, white borders, minimal layout, and max-width centered content. Use for new pages, components, or when asked to match his existing style.
description: Applies the Darkmatter aesthetic - Commit Mono font, #121113 background, white borders, minimal layout, and max-width centered content. Use for new pages, components, or when asked to match the Andromeda style.
---

# Darkmatter Styles

## Overview

Steve's personal web aesthetic: dark, minimal, monospace. No frameworks, no decorative flourishes. Everything is functional and stark.
The Darkmatter aesthetic: dark, minimal, monospace. No frameworks, no decorative flourishes. Everything is functional and stark.

## Core Palette


1	1		# Cellar
2		-	#
3		-	![demo of cellar](https://files.stevedylan.dev/cellar-demo.png)
4	2
5		-	A minimal wine collection tracker
6		-
7		-	## Overview
	3	+	![demo of cellar](https://files.stevedylan.dev/cellar-demo.png)
8	4
9	5		A simple, self-hosted wine collection app built with Rust.
10	6

17	13		- Dark themed UI with Commit Mono font
18	14		- SQLite for persistent storage
19	15
20		-	## Quickstart
21		-
22		-	```bash
23		-	git clone https://github.com/stevedylandev/cellar.git
24		-	cd cellar
25		-	cp .env.example .env
26		-	# Edit .env with your password and Anthropic API key
27		-	cargo build --release
28		-	./target/release/cellar
29		-	```
	16	+	## Configure
30	17
31	18		### Environment Variables
32	19

39	26		\| `PORT` \| Server port \| `3000` \|
40	27		\| `COOKIE_SECURE` \| Enable HTTPS-only cookies \| `false` \|
41	28
42		-	## Routes
	29	+	The `ANTHROPIC_API_KEY` is optional but required for AI-powered tasting notes and image analysis.
43	30
44		-	### Public
	31	+	## Deploy
45	32
46		-	\| Method \| Route \| Description \|
47		-	\|---\|---\|---\|
48		-	\| `GET` \| `/` \| Wine collection list \|
49		-	\| `GET` \| `/wines/{short_id}` \| Wine detail page \|
50		-	\| `GET` \| `/wines/{short_id}/image` \| Wine image \|
	33	+	### Railway
51	34
52		-	### Admin
53		-
54		-	All admin routes (except login) require an authenticated session.
55		-
56		-	\| Method \| Route \| Description \|
57		-	\|---\|---\|---\|
58		-	\| `GET/POST` \| `/admin/login` \| Login page \|
59		-	\| `GET` \| `/admin/logout` \| Logout \|
60		-	\| `GET` \| `/admin` \| Admin dashboard \|
61		-	\| `GET/POST` \| `/admin/new` \| Add a new wine \|
62		-	\| `GET/POST` \| `/admin/edit/{short_id}` \| Edit a wine \|
63		-	\| `POST` \| `/admin/delete/{short_id}` \| Delete a wine \|
64		-	\| `POST` \| `/admin/analyze-image` \| AI image analysis via Claude \|
65		-
66		-	## Structure
67		-
68		-	```
69		-	cellar/
70		-	├── src/
71		-	│ ├── main.rs # App entrypoint, env vars, starts server
72		-	│ ├── server.rs # Axum router, HTTP handlers, and templates
73		-	│ ├── auth.rs # Password verification and session management
74		-	│ ├── claude.rs # Anthropic API integration for tasting notes
75		-	│ └── db.rs # SQLite database layer (wines, sessions)
76		-	├── templates/ # Askama HTML templates
77		-	│ ├── base.html # Base layout with header and nav
78		-	│ ├── login.html # Login page
79		-	│ ├── index.html # Wine collection list
80		-	│ ├── wine.html # Single wine display
81		-	│ ├── wine_form.html # Add/edit wine form
82		-	│ └── admin.html # Admin page
83		-	├── static/ # Favicons, og:image, styles, and webmanifest
84		-	├── Dockerfile # Multi-stage build (Rust + Debian slim)
85		-	└── docker-compose.yml
86		-	```
87		-
88		-	## Deployment
89		-
90		-	### Railway
	35	+	The easiest way to deploy Cellar is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. Cellar requires `CELLAR_PASSWORD` during the configure step, and optionally `ANTHROPIC_API_KEY` if you want AI-powered tasting notes and image analysis.
91	36
92	37		[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/MNprVh?referralCode=JGcIp6)
93	38

105	50
106	51		### Binary
107	52
	53	+	Install with Homebrew:
	54	+
108	55		```bash
109		-	cargo build --release
	56	+	brew install stevedylandev/tap/cellar
	57	+	```
	58	+
	59	+	Or grab a prebuilt binary from the [releases page](https://github.com/stevedylandev/andromeda/releases?q=cellar&expanded=true).
	60	+
	61	+	You can also build from source:
	62	+
	63	+	```bash
	64	+	cargo build --release -p cellar
110	65		```
111	66
112	67		The resulting binary at `./target/release/cellar` is self-contained with all assets embedded. Copy it to your server with a configured `.env` file and run it directly.
	68	+
	69	+	## Use
	70	+
	71	+	Your wine collection is publicly viewable at `/` with individual wine pages at `/wines/{short_id}`.
	72	+
	73	+	### Admin
	74	+
	75	+	Log in at `/admin/login` with your configured password to access the admin pages.
	76	+
	77	+	\| Page \| Description \|
	78	+	\|---\|---\|
	79	+	\| `/admin` \| Admin dashboard listing every wine in your collection \|
	80	+	\| `/admin/new` \| Add a new wine, optionally using AI image analysis to prefill details \|
	81	+	\| `/admin/edit/{short_id}` \| Edit an existing wine \|

2	2		#
3	3		![demo of feeds](https://files.stevedylan.dev/feeds-demo.png)
4	4
5		-	Minimal RSS Feeds
6		-
7		-	## Overview
8		-
9	5		Feeds is a minimal RSS reader that mimics the original experience of RSS. It's just a list of posts. No categories, no marking a post read or unread, and there is no in-app reading. With this approach you have to read the post on the author's personal website and experience it in its original context.
10	6
11	7		- Single Rust binary with embedded assets

14	10		- Feeds API with JSON and OPML export
15	11		- Dark themed UI with Commit Mono font
16	12
17		-	## Quickstart
18		-
19		-	```bash
20		-	git clone https://github.com/stevedylandev/andromeda.git
21		-	cd andromeda
22		-	cargo run -p feeds
23		-	# Server running on http://localhost:3000
24		-	```
	13	+	## Configure
25	14
26	15		### Environment Variables
27	16
28	17		\| Variable \| Description \| Default \|
29	18		\|---\|---\|---\|
	19	+	\| `DEFAULT_FEED` \| Comma-separated list of RSS feed URLs to load when no `?url=` or `?urls=` query param is provided \| -- \|
30	20		\| `FRESHRSS_URL` \| URL of your FreshRSS instance \| -- \|
31	21		\| `FRESHRSS_USERNAME` \| FreshRSS username \| -- \|
32	22		\| `FRESHRSS_PASSWORD` \| FreshRSS password \| -- \|
33	23		\| `ADMIN_PASSWORD` \| Password for the admin panel \| -- \|
34	24		\| `COOKIE_SECURE` \| Enable HTTPS-only cookies \| `false` \|
35	25
36		-	## Usage
	26	+	The FreshRSS credentials are only needed if you want to source feeds from a FreshRSS instance.
	27	+
	28	+	## Deploy
	29	+
	30	+	### Railway
	31	+
	32	+	The easiest way to deploy Feeds is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. Feeds requires `ADMIN_PASSWORD` to enable the admin panel, and optionally the `FRESHRSS_*` variables if you want to source feeds from a FreshRSS instance.
	33	+
	34	+	[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/Ezvmhx?referralCode=JGcIp6)
	35	+
	36	+	### Docker
	37	+
	38	+	```bash
	39	+	cd apps/feeds
	40	+	cp .env.sample .env
	41	+	# Edit .env with your credentials
	42	+	docker compose up -d
	43	+	```
	44	+
	45	+	### Binary
	46	+
	47	+	Install with Homebrew:
	48	+
	49	+	```bash
	50	+	brew install stevedylandev/tap/feeds
	51	+	```
	52	+
	53	+	Or grab a prebuilt binary from the [releases page](https://github.com/stevedylandev/andromeda/releases?q=feeds&expanded=true).
	54	+
	55	+	You can also build from source:
	56	+
	57	+	```bash
	58	+	cargo build --release -p feeds
	59	+	```
	60	+
	61	+	The resulting binary is self-contained with all assets embedded. Copy it to your server with a configured `.env` file and run it directly.
	62	+
	63	+	## Use
37	64
38	65		There are several built-in ways to source RSS feeds.
39	66

49	76
50	77		```
51	78		?urls=https://bearblog.dev/discover/feed/,https://bearblog.stevedylan.dev/feed/
	79	+	```
	80	+
	81	+	### Default Feed
	82	+
	83	+	Set the `DEFAULT_FEED` environment variable to a comma-separated list of feed URLs and the app will load them whenever no `?url=` or `?urls=` query param is provided:
	84	+
	85	+	```
	86	+	DEFAULT_FEED=https://bearblog.dev/discover/feed/,https://bearblog.stevedylan.dev/feed/
52	87		```
53	88
54	89		### OPML File

77	112		/feeds?format=json
78	113		/feeds?format=opml
79	114		```
80		-
81		-	## Structure
82		-
83		-	```
84		-	feeds/
85		-	├── src/
86		-	│ ├── main.rs # Axum server with routing, templates, and static asset serving
87		-	│ ├── feeds.rs # Feed fetching, OPML parsing, and FreshRSS API integration
88		-	│ ├── auth.rs # Session-based authentication with constant-time password verification
89		-	│ └── models.rs # Data structures for feeds and FreshRSS responses
90		-	├── templates/ # Askama HTML templates
91		-	├── assets/ # Static assets embedded at compile time via rust-embed
92		-	├── Dockerfile
93		-	└── docker-compose.yml
94		-	```
95		-
96		-	## Deployment
97		-
98		-	### Railway
99		-
100		-	[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/Ezvmhx?referralCode=JGcIp6)
101		-
102		-	### Docker
103		-
104		-	```bash
105		-	cd apps/feeds
106		-	cp .env.sample .env
107		-	# Edit .env with your credentials
108		-	docker compose up -d
109		-	```
110		-
111		-	### Binary
112		-
113		-	```bash
114		-	cargo build --release -p feeds
115		-	```
116		-
117		-	The resulting binary is self-contained with all assets embedded. Copy it to your server with a configured `.env` file and run it directly.

2	2
3	3		![demo of jotts](https://files.stevedylan.dev/jotts-demo.png)
4	4
5		-	A minimal notes app
6		-
7		-	## Overview
8		-
9	5		A simple, self-hosted markdown note app built with Rust.
10	6
11	7		- Single ~7MB Rust binary with embedded assets

15	11		- Dark themed UI with Commit Mono font
16	12		- SQLite for persistent storage
17	13
18		-	## Quickstart
19		-
20		-	```bash
21		-	git clone https://github.com/stevedylandev/andromeda.git
22		-	cd andromeda
23		-	cp apps/jotts/.env.example .env
24		-	# Edit .env with your password
25		-	cargo run -p jotts
26		-	```
	14	+	## Configure
27	15
28	16		### Environment Variables
29	17

35	23		\| `PORT` \| Server port \| `3000` \|
36	24		\| `COOKIE_SECURE` \| Enable HTTPS-only cookies \| `false` \|
37	25
38		-	## Structure
39		-
40		-	```
41		-	jotts/
42		-	├── src/
43		-	│ ├── main.rs # App entrypoint, env vars, starts server
44		-	│ ├── server.rs # Axum router, HTTP handlers, and templates
45		-	│ ├── auth.rs # Password verification and session management
46		-	│ └── db.rs # SQLite database layer (notes, sessions)
47		-	├── templates/ # Askama HTML templates
48		-	│ ├── base.html # Base layout with header and nav
49		-	│ ├── login.html # Login page
50		-	│ ├── index.html # Note list
51		-	│ ├── view.html # Single note display
52		-	│ ├── new.html # Create note form
53		-	│ └── edit.html # Edit note form
54		-	├── static/ # Favicons, og:image, styles, and webmanifest
55		-	├── assets/ # Commit Mono font files
56		-	├── Dockerfile
57		-	└── docker-compose.yml
58		-	```
	26	+	## Deploy
59	27
60		-	## Deployment
	28	+	### Railway
61	29
62		-	### Railway
	30	+	The easiest way to deploy Jotts is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. Jotts requires `JOTTS_PASSWORD` to be set during the configure step.
63	31
64	32		[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/DLhUhH?referralCode=JGcIp6)
65	33

76	44
77	45		### Binary
78	46
	47	+	Install with Homebrew:
	48	+
	49	+	```bash
	50	+	brew install stevedylandev/tap/jotts
	51	+	```
	52	+
	53	+	Or grab a prebuilt binary from the [releases page](https://github.com/stevedylandev/andromeda/releases?q=jotts&expanded=true).
	54	+
	55	+	You can also build from source:
	56	+
79	57		```bash
80	58		cargo build --release -p jotts
81	59		```
82	60
83	61		The resulting binary is self-contained with all assets embedded. Copy it to your server with a configured `.env` file and run it directly.
	62	+
	63	+	## Use
	64	+
	65	+	Log in at `/login` with your configured password. From there you can create, edit, and delete markdown notes. Notes support GitHub-flavored markdown including strikethrough, tables, and task lists.

2	2
3	3		![demo of og](https://files.stevedylan.dev/og-demo.png)
4	4
5		-	A simple web tool for inspecting Open Graph tags on any URL.
6		-
7		-	## Overview
8		-
9	5		A self-hosted Open Graph tag inspector built with Rust. Enter any URL and instantly see its OG metadata.
10	6
11	7		- Single Rust binary with embedded assets

13	9		- Dark themed UI with Commit Mono font
14	10		- No database needed -- fully stateless
15	11
16		-	## Quickstart
17		-
18		-	```bash
19		-	git clone https://github.com/stevedylandev/andromeda.git
20		-	cd andromeda
21		-	cargo run -p og
22		-	```
	12	+	## Configure
23	13
24	14		### Environment Variables
25	15

27	17		\|---\|---\|---\|
28	18		\| `PORT` \| Server port \| `3000` \|
29	19
30		-	## Structure
	20	+	## Deploy
31	21
32		-	```
33		-	og/
34		-	├── src/
35		-	│ ├── main.rs # Entry point and server startup
36		-	│ ├── server.rs # Axum routes and request handling
37		-	│ └── og.rs # Open Graph tag fetching and parsing
38		-	├── templates/ # Askama HTML templates
39		-	│ ├── base.html # Base layout
40		-	│ ├── index.html # Search form
41		-	│ └── results.html # OG tag results display
42		-	├── static/ # Fonts, favicons, and styles
43		-	├── Dockerfile
44		-	└── docker-compose.yml
45		-	```
	22	+	### Railway
46	23
47		-	## Deployment
48		-
49		-	### Railway
	24	+	The easiest way to deploy OG is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. OG is fully stateless and needs no environment variables beyond the defaults.
50	25
51	26		[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/OdXBt_?referralCode=JGcIp6)
52	27

59	34
60	35		### Binary
61	36
	37	+	Install with Homebrew:
	38	+
	39	+	```bash
	40	+	brew install stevedylandev/tap/og
	41	+	```
	42	+
	43	+	Or grab a prebuilt binary from the [releases page](https://github.com/stevedylandev/andromeda/releases?q=og&expanded=true).
	44	+
	45	+	You can also build from source:
	46	+
62	47		```bash
63	48		cargo build --release -p og
64	49		```
65	50
66	51		The resulting binary is self-contained with all assets embedded. Copy it to your server and run it directly.
	52	+
	53	+	## Use
	54	+
	55	+	Enter any URL to inspect its Open Graph tags including title, description, and image. Results are displayed instantly with no account or configuration needed.

2	2
3	3		![demo of parcels](https://files.stevedylan.dev/parcels-demo.png)
4	4
5		-	A minimal package tracking app
6	5
7	6		:::warning
8	7		This app originally used USPS, but starting April 1st 2026, it has become much harder to obtain/maintain API keys.
9	8		:::
10		-
11		-	## Overview
12	9
13	10		A self-hosted package tracker for USPS. Track your packages without logging into USPS every time.
14	11

18	15		- Track USPS packages with custom labels
19	16		- Delete packages you no longer want to track
20	17
21		-	## Quickstart
22		-
23		-	```bash
24		-	git clone https://github.com/stevedylandev/andromeda.git
25		-	cd andromeda
26		-	cp apps/parcels/.env.example .env
27		-	# Edit .env with your USPS API credentials and app password
28		-	cargo run -p parcels
29		-	```
	18	+	## Configure
30	19
31	20		You'll need a [USPS Web Tools API](https://developer.usps.com) account to get your `USPS_CLIENT_ID` and `USPS_CLIENT_SECRET`.
32	21

41	30		\| `PORT` \| Server port \| `3000` \|
42	31		\| `COOKIE_SECURE` \| Enable HTTPS-only cookies \| `false` \|
43	32
44		-	## Structure
	33	+	## Deploy
45	34
46		-	```
47		-	parcels/
48		-	├── src/
49		-	│ ├── main.rs # Axum web server, routes, and app state
50		-	│ ├── auth.rs # Password verification and session management
51		-	│ ├── db.rs # SQLite database layer (packages, events, sessions)
52		-	│ └── usps.rs # USPS API integration with OAuth2 token caching
53		-	├── templates/ # Askama HTML templates
54		-	│ ├── base.html # Base layout
55		-	│ ├── index.html # Package list
56		-	│ ├── detail.html # Package detail with tracking events
57		-	│ ├── add.html # Add package form
58		-	│ └── login.html # Login page
59		-	├── static/ # Fonts, favicons, and images
60		-	├── Dockerfile
61		-	└── docker-compose.yml
62		-	```
	35	+	### Railway
63	36
64		-	## Deployment
65		-
66		-	### Railway
	37	+	The easiest way to deploy Parcels is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. Parcels requires `APP_PASSWORD`, `USPS_CLIENT_ID`, and `USPS_CLIENT_SECRET` to be set during the configure step.
67	38
68	39		[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/HNQUs4?referralCode=JGcIp6)
69	40

79	50		This will start Parcels on port `3000` with a persistent volume for the SQLite database.
80	51
81	52		### Binary
	53	+
	54	+	Install with Homebrew:
	55	+
	56	+	```bash
	57	+	brew install stevedylandev/tap/parcels
	58	+	```
	59	+
	60	+	Or grab a prebuilt binary from the [releases page](https://github.com/stevedylandev/andromeda/releases?q=parcels&expanded=true).
	61	+
	62	+	You can also build from source:
82	63
83	64		```bash
84	65		cargo build --release -p parcels
85	66		```
86	67
87	68		The resulting binary is self-contained (~7MB). Copy it to your server with a configured `.env` file and run it directly.
	69	+
	70	+	## Use
	71	+
	72	+	Log in with your configured password, then add packages by entering a USPS tracking number and an optional label. Your packages and their tracking events are displayed on the main page. Delete packages you no longer need to track.

2	2
3	3		![demo of posts](https://assets.andromeda.build/posts-demo.png)
4	4
5		-	A minimal CMS blog with admin interface
6		-
7		-	## Overview
8		-
9	5		A self-hosted blog CMS built with Rust.
10	6
11	7		- Single Rust binary with embedded assets

18	14		- Dark themed UI with Commit Mono font
19	15		- SQLite for persistent storage
20	16
21		-	## Quickstart
22		-
23		-	```bash
24		-	git clone https://github.com/stevedylandev/andromeda.git
25		-	cd andromeda
26		-	cp apps/posts/.env.example .env
27		-	# Edit .env with your password
28		-	cargo run -p posts
29		-	```
	17	+	## Configure
30	18
31	19		### Environment Variables
32	20

40	28		\| `PORT` \| Server port \| `3000` \|
41	29		\| `COOKIE_SECURE` \| Enable HTTPS-only cookies \| `false` \|
42	30
43		-	## Structure
	31	+	## Deploy
44	32
45		-	```
46		-	posts/
47		-	├── src/
48		-	│ ├── main.rs # App entrypoint, env vars, starts server
49		-	│ ├── server.rs # Axum router, HTTP handlers, and templates
50		-	│ ├── auth.rs # Password verification and session management
51		-	│ └── db.rs # SQLite database layer (posts, pages, files, settings, sessions)
52		-	├── templates/ # Askama HTML templates
53		-	│ ├── base.html # Public base layout
54		-	│ ├── index.html # Blog home page
55		-	│ ├── post.html # Single post view
56		-	│ ├── posts.html # Post listing
57		-	│ ├── page.html # Static page view
58		-	│ ├── login.html # Login page
59		-	│ ├── admin_base.html # Admin layout
60		-	│ ├── admin_index.html # Admin dashboard
61		-	│ ├── admin_post_form.html # Create/edit post form
62		-	│ ├── admin_pages.html # Admin page listing
63		-	│ ├── admin_page_form.html # Create/edit page form
64		-	│ ├── admin_files.html # File upload management
65		-	│ └── admin_settings.html # Blog settings
66		-	├── static/ # Favicons, fonts, and styles
67		-	├── uploads/ # Uploaded files directory
68		-	├── Dockerfile
69		-	└── docker-compose.yml
70		-	```
	33	+	### Railway
71	34
72		-	## Deployment
73		-
74		-	### Railway
	35	+	The easiest way to deploy Posts is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. Posts requires `POSTS_PASSWORD` and `SITE_URL` to be set during the configure step.
75	36
76	37		[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/tYtJYp?referralCode=JGcIp6)
77	38

88	49
89	50		### Binary
90	51
	52	+	Install with Homebrew:
	53	+
	54	+	```bash
	55	+	brew install stevedylandev/tap/posts
	56	+	```
	57	+
	58	+	Or grab a prebuilt binary from the [releases page](https://github.com/stevedylandev/andromeda/releases?q=posts&expanded=true).
	59	+
	60	+	You can also build from source:
	61	+
91	62		```bash
92	63		cargo build --release -p posts
93	64		```
94	65
95	66		The resulting binary is self-contained with all assets embedded. Copy it to your server with a configured `.env` file and run it directly.
	67	+
	68	+	## Use
	69	+
	70	+	Log in at `/login` with your configured password to access the admin panel. From there you can manage blog posts, static pages, file uploads, and site settings including custom CSS. Your blog's RSS feed is available at `/feed.xml`.

2	2
3	3		![demo of shrink](https://files.stevedylan.dev/shrink-demo.png)
4	4
5		-	A minimal image compression app
6		-
7		-	## Overview
8		-
9	5		A simple self-hosted tool for compressing and resizing images. Upload an image, set your desired quality and optional width, and download the compressed JPEG.
10	6
11	7		- Single Rust binary

13	9		- Optional resize by width (preserves aspect ratio)
14	10		- 20MB upload limit
15	11
16		-	## Quickstart
17		-
18		-	```bash
19		-	git clone https://github.com/stevedylandev/andromeda.git
20		-	cd andromeda
21		-	cargo run -p shrink
22		-	```
	12	+	## Configure
23	13
24	14		### Environment Variables
25	15

28	18		\| `HOST` \| Server bind host \| `127.0.0.1` \|
29	19		\| `PORT` \| Server bind port \| `3000` \|
30	20
31		-	## Structure
32		-
33		-	```
34		-	shrink/
35		-	├── src/
36		-	│ ├── main.rs # Entry point and server startup
37		-	│ └── server.rs # Axum routes and image compression logic
38		-	├── templates/
39		-	│ └── index.html # Upload UI
40		-	├── static/ # Fonts and static assets
41		-	├── Dockerfile
42		-	└── docker-compose.yml
43		-	```
44		-
45		-	## Deployment
	21	+	## Deploy
46	22
47	23		### Railway
	24	+
	25	+	The easiest way to deploy Shrink is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. Shrink needs no environment variables beyond the defaults.
48	26
49	27		[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/enYUFb?referralCode=JGcIp6)
50	28

59	37
60	38		### Binary
61	39
	40	+	Install with Homebrew:
	41	+
	42	+	```bash
	43	+	brew install stevedylandev/tap/shrink
	44	+	```
	45	+
	46	+	Or grab a prebuilt binary from the [releases page](https://github.com/stevedylandev/andromeda/releases?q=shrink&expanded=true).
	47	+
	48	+	You can also build from source:
	49	+
62	50		```bash
63	51		cargo build --release -p shrink
64	52		```
65	53
66	54		The resulting binary is self-contained. Copy it to your server and run it directly.
	55	+
	56	+	## Use
	57	+
	58	+	Upload an image, set your desired quality (1-100) and an optional target width, then download the compressed JPEG. Aspect ratio is preserved when resizing.

2	2
3	3		![demo of sipp](https://files.stevedylan.dev/sipp-demo.png)
4	4
5		-	Minimal code sharing
6		-
7		-	## Overview
8		-
9	5		A single binary for code sharing with a web server and interactive TUI.
10	6
11	7		- Create snippets and share on the web

17	13		A small demo instance runs at [sipp.so](https://sipp.so). All snippets created there are public and might be deleted at any time; host your own instance with your own API key for personal use!
18	14		:::
19	15
20		-	## Quickstart
	16	+	## Install
	17	+
	18	+	Sipp can be installed several ways:
	19	+
	20	+	### Homebrew
21	21
22	22		```bash
23		-	cargo install sipp-so
24		-	sipp --help
	23	+	brew install stevedylandev/tap/sipp-so
25	24		```
26	25
27		-	Start a server and create a snippet:
	26	+	### Cargo
28	27
29	28		```bash
30		-	sipp server --port 3000
	29	+	cargo install sipp-so
31	30		```
32	31
33		-	```bash
34		-	# Path to file
35		-	sipp path/to/file.rs
	32	+	### Releases
36	33
37		-	# Or use the interactive TUI
38		-	sipp
39		-	```
	34	+	Visit the [releases](https://github.com/stevedylandev/sipp/releases) page for binaries and install scripts.
40	35
41		-	### Install
	36	+	## Configure
42	37
43		-	Sipp can be installed several ways:
	38	+	### Environment Variables
44	39
45		-	#### Homebrew
	40	+	\| Variable \| Description \|
	41	+	\|---\|---\|
	42	+	\| `SIPP_API_KEY` \| API key for protecting endpoints \|
	43	+	\| `SIPP_AUTH_ENDPOINTS` \| Comma-separated list of endpoints requiring auth: `api_list`, `api_create`, `api_get`, `api_delete`, `all`, or `none` (defaults to `api_delete,api_list`) \|
	44	+	\| `SIPP_MAX_CONTENT_SIZE` \| Maximum snippet content size in bytes (defaults to `512000` / 500 KB) \|
	45	+	\| `SIPP_DB_PATH` \| Custom path for the SQLite database file (defaults to `sipp.sqlite`) \|
	46	+
	47	+	## Deploy
	48	+
	49	+	### Railway
	50	+
	51	+	The easiest way to deploy a Sipp server is with the one-click Railway template. See the [Deploying with Railway](/deploy-railway) guide for a walkthrough of the process. Set `SIPP_API_KEY` during the configure step to protect your authenticated endpoints.
	52	+
	53	+	[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/Axcf_D?referralCode=JGcIp6)
	54	+
	55	+	### Docker
46	56
47	57		```bash
48		-	brew install stevedylandev/tap/sipp-so
	58	+	SIPP_API_KEY=your-secret-key docker compose up -d
49	59		```
50	60
51		-	#### Cargo
	61	+	### Binary
52	62
53	63		```bash
54		-	cargo install sipp-so
	64	+	cargo build --release -p sipp
55	65		```
56	66
57		-	#### Releases
	67	+	The resulting binary is self-contained with all assets embedded. Copy it to your server with your environment variables configured and run it directly.
58	68
59		-	Visit the [releases](https://github.com/stevedylandev/sipp/releases) page for binaries and install scripts.
	69	+	## Use
60	70
61		-	## CLI
	71	+	### CLI
62	72
63	73		```
64	74		sipp [OPTIONS] [FILE] [COMMAND]
65	75		```
66	76
67		-	### Commands
	77	+	#### Commands
68	78
69	79		\| Command \| Description \|
70	80		\|---\|---\|

72	82		\| `tui` \| Launch the interactive TUI \|
73	83		\| `auth` \| Save remote URL and API key to config file \|
74	84
75		-	### Arguments
	85	+	#### Arguments
76	86
77	87		\| Argument \| Description \|
78	88		\|---\|---\|
79	89		\| `[FILE]` \| File path to create a snippet from \|
80	90
81		-	### Options
	91	+	#### Options
82	92
83	93		\| Option \| Description \|
84	94		\|---\|---\|
85	95		\| `-r, --remote <URL>` \| Remote server URL (env: `SIPP_REMOTE_URL`) \|
86	96		\| `-k, --api-key <KEY>` \| API key for authenticated operations (env: `SIPP_API_KEY`) \|
87	97
88		-	## Server
	98	+	### Server
89	99
90		-	Sipp includes a built-in web server powered by Axum. Start it with:
	100	+	Start the web server with:
91	101
92	102		```bash
93	103		sipp server --port 3000 --host localhost
94	104		```
95	105
96		-	### Environment Variables
97		-
98		-	\| Variable \| Description \|
99		-	\|---\|---\|
100		-	\| `SIPP_API_KEY` \| API key for protecting endpoints \|
101		-	\| `SIPP_AUTH_ENDPOINTS` \| Comma-separated list of endpoints requiring auth: `api_list`, `api_create`, `api_get`, `api_delete`, `all`, or `none` (defaults to `api_delete,api_list`) \|
102		-	\| `SIPP_MAX_CONTENT_SIZE` \| Maximum snippet content size in bytes (defaults to `512000` / 500 KB) \|
103		-	\| `SIPP_DB_PATH` \| Custom path for the SQLite database file (defaults to `sipp.sqlite`) \|
104		-
105		-	### API Endpoints
	106	+	#### API Endpoints
106	107
107	108		\| Method \| Endpoint \| Description \|
108	109		\|---\|---\|---\|

114	115
115	116		Authenticated endpoints require an `x-api-key` header.
116	117
117		-	### Raw Output for CLI Tools
	118	+	#### Raw Output for CLI Tools
118	119
119	120		When you access a snippet URL (`/s/{short_id}`) with `curl`, `wget`, or `httpie`, the server returns the raw content as plain text instead of HTML:
120	121

122	123		curl https://sipp.so/s/abc123
123	124		```
124	125
125		-	## TUI
	126	+	### TUI
126	127
127	128		The Sipp TUI makes it easy to create, copy, share, and manage your snippets either locally or remotely.
128	129

137	138		sipp -r https://sipp.so -k your-api-key
138	139		```
139	140
140		-	### Local Access
	141	+	#### Local Access
141	142
142	143		If you are running `sipp` in the same directory as the `sipp.sqlite` file created by the server instance, the TUI will automatically access the database locally.
143	144
144		-	### Remote Access
	145	+	#### Remote Access
145	146
146	147		To access a remote instance:
147	148		- Set the `SIPP_API_KEY` variable in your server instance
148	149		- Run `sipp auth` to enter your server URL and API key, stored under `$HOME/.config/sipp`
149	150
150		-	### Keybindings
	151	+	#### Keybindings
151	152
152	153		\| Key \| Action \|
153	154		\|---\|---\|

165	166		\| `r` \| Refresh snippets (remote only) \|
166	167		\| `q` \| Quit \|
167	168		\| `?` \| Toggle help \|
168		-
169		-	## Structure
170		-
171		-	```
172		-	sipp/
173		-	├── src/
174		-	│ ├── main.rs # CLI argument parsing and entry point
175		-	│ ├── lib.rs # Library exports
176		-	│ ├── server.rs # Axum web server, routes, and templates
177		-	│ ├── tui.rs # Interactive terminal UI
178		-	│ ├── db.rs # SQLite database layer
179		-	│ ├── backend.rs # Local/remote backend abstraction
180		-	│ ├── config.rs # Config file management
181		-	│ └── highlight.rs # Syntax highlighting with custom themes
182		-	├── templates/ # Askama HTML templates
183		-	├── static/ # Fonts, favicons, and styles
184		-	├── Dockerfile
185		-	└── docker-compose.yml
186		-	```
187		-
188		-	## Deployment
189		-
190		-	### Railway
191		-
192		-	[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/Axcf_D?referralCode=JGcIp6)
193		-
194		-	### Docker
195		-
196		-	```bash
197		-	SIPP_API_KEY=your-secret-key docker compose up -d
198		-	```
199		-
200		-	### Binary
201		-
202		-	```bash
203		-	cargo build --release -p sipp
204		-	```
205		-
206		-	The resulting binary is self-contained with all assets embedded. Copy it to your server with your environment variables configured and run it directly.

1	1		# Skills
2	2
3		-	Andromeda apps are scaffolded using [Claude Code](https://claude.ai/code) with a custom skill called `rust-crud`. This page explains how to use it to build your own apps in the same style.
	3	+	Andromeda ships with two [Claude Code](https://claude.ai/code) skills that make it easy to build new apps in the same style. Both live in the repo at [`skills/`](https://github.com/stevedylandev/andromeda/tree/main/skills).
4	4
5		-	## What is rust-crud?
	5	+	## andromeda-stack
6	6
7		-	`rust-crud` is a Claude Code skill that scaffolds a complete Rust CRUD web application matching the Andromeda stack:
	7	+	[`andromeda-stack`](https://github.com/stevedylandev/andromeda/blob/main/skills/andromeda-stack/SKILL.md) scaffolds a complete Rust CRUD web app matching the Andromeda stack:
8	8
9	9		- Axum web server with routing
10	10		- SQLite database with rusqlite
11	11		- Askama HTML templates
12		-	- API key authentication
	12	+	- `andromeda-auth` for session or API key auth
13	13		- Embedded static assets via rust-embed
14	14		- Dockerfile and docker-compose.yml for deployment
15	15
16		-	## Using the Skill
	16	+	New apps land under `apps/` in the workspace and share dependencies via the root `Cargo.toml`.
17	17
18		-	In Claude Code, invoke the skill when you want to create a new app:
	18	+	## darkmatter-styles
19	19
20		-	```
21		-	/rust-crud
22		-	```
	20	+	[`darkmatter-styles`](https://github.com/stevedylandev/andromeda/tree/main/skills/darkmatter-styles/SKILL.md) applies the shared Andromeda aesthetic: dark background, white borders, Commit Mono, minimal layout, no frameworks. Use it when building new pages or components that need to match the rest of the lineup.
23	21
24		-	Describe what you want to build and the skill will generate a complete, working app that follows the same patterns as every other Andromeda app.
	22	+	## Installing
25	23
26		-	## Building Your Own App
27		-
28		-	If you want to add a new app to the workspace manually, follow these steps:
29		-
30		-	### 1. Create the app directory
	24	+	Use [`npx skills add`](https://github.com/vercel-labs/skills) to pull either skill directly from the repo:
31	25
32	26		```bash
33		-	mkdir -p apps/my-app/src
34		-	mkdir -p apps/my-app/templates
35		-	mkdir -p apps/my-app/static
36		-	```
37		-
38		-	### 2. Add to workspace
39		-
40		-	Add your app to the root `Cargo.toml` workspace members:
41		-
42		-	```toml
43		-	[workspace]
44		-	members = [
45		-	"apps/my-app",
46		-	# ...existing apps
47		-	]
	27	+	npx skills add stevedylandev/andromeda/skills
48	28		```
49	29
50		-	### 3. Set up Cargo.toml
51		-
52		-	```toml
53		-	[package]
54		-	name = "my-app"
55		-	version = "0.1.0"
56		-	edition = "2021"
57		-
58		-	[dependencies]
59		-	axum = "0.8"
60		-	tokio = { version = "1", features = ["full"] }
61		-	rusqlite = { version = "0.32", features = ["bundled"] }
62		-	askama = "0.12"
63		-	askama_axum = "0.4"
64		-	rust-embed = "8"
65		-	tower-http = { version = "0.6", features = ["cors"] }
66		-	serde = { version = "1", features = ["derive"] }
67		-	dotenvy = "0.15"
68		-	```
69		-
70		-	### 4. Follow the pattern
71		-
72		-	Use the [Stack](/diy/stack) page as a reference for how to structure your `main.rs`, `server.rs`, and `db.rs` files. Look at any existing app in `apps/` for a working example.
73		-
74		-	### 5. Build and run
75		-
76		-	```bash
77		-	cargo run -p my-app
78		-	```
	30	+	Once installed, invoke them in Claude Code by describing what you want to build — the skills trigger automatically based on their descriptions.

7	7		markdown: {
8	8		code: {
9	9		themes: {
10		-	light: "min-light",
11		-	dark: "slack-dark",
	10	+	light: "github-light-default",
	11	+	dark: "github-dark-default",
12	12		},
13	13		},
14	14		},

30	30		{
31	31		text: 'What is Andromeda',
32	32		link: '/what-is-andromeda',
	33	+	},
	34	+	{
	35	+	text: 'Deploying with Railway',
	36	+	link: '/deploy-railway',
33	37		},
34	38		],
35	39		},

1	1		---
2	2		name: darkmatter-styles
3		-	description: Use when building any web UI for Steve - applies his personal dark aesthetic with Commit Mono font, #121113 background, white borders, minimal layout, and max-width centered content. Use for new pages, components, or when asked to match his existing style.
	3	+	description: Applies the Darkmatter aesthetic - Commit Mono font, #121113 background, white borders, minimal layout, and max-width centered content. Use for new pages, components, or when asked to match the Andromeda style.
4	4		---
5	5
6	6		# Darkmatter Styles
7	7
8	8		## Overview
9	9
10		-	Steve's personal web aesthetic: dark, minimal, monospace. No frameworks, no decorative flourishes. Everything is functional and stark.
	10	+	The Darkmatter aesthetic: dark, minimal, monospace. No frameworks, no decorative flourishes. Everything is functional and stark.
11	11
12	12		## Core Palette
13	13