introducing-returnspace

title: “Introducing ReturnSpace: The Blog System That Gives You Your Power Back” date: 2026-02-11 description: “A deep dive into the custom blogging platform built for privacy, simplicity, and complete creative control—featuring TUI-driven workflows, password protection, and zero tracking.” tags: [“meta”, “hugo”, “privacy”, “development”]

The Problem with Modern Blogging

We’ve all been there. You want to share your thoughts online, but the options are… less than ideal. Medium wants to own your content and paywall your readers. WordPress is a security nightmare requiring constant updates. Substack takes a cut of your money. Ghost costs $9/month minimum. And don’t even get me started on the analytics tracking, the algorithmic feeds, the “engagement optimization.”

What if blogging could be simple again?

Introducing ReturnSpace

ReturnSpace is a custom-built blogging platform that puts you back in control. No databases. No admin panels. No JavaScript frameworks. Just you, your words, and a set of powerful command-line tools that make publishing feel like magic.

Built on Hugo, deployed to DigitalOcean, and cached globally by Cloudflare, it’s a static site that loads in milliseconds while giving you features that most blogging platforms charge premium prices for.

The Stats

The Features That Make It Special

🔐 Password Protection (Without JavaScript)

Want to share something with just a few people? Each post can have its own password, enforced at the CDN level. No cookies, no sessions, no tracking—just HTTP Basic Auth that works everywhere.

# Publishing a password-protected post is one command
./scripts/publish.sh my-draft.md --password

Protected posts are automatically excluded from RSS feeds and search engines. Privacy by design, not by configuration.

🖥️ TUI-Driven Workflows

Everything happens in the terminal, with beautiful TUI menus powered by fzf and gum. No clicking through web interfaces. No waiting for page loads.

[Image: The interactive post selection menu showing fuzzy search]

# Want to edit a post? Just run:
./scripts/edit.sh

# The TUI shows you all your posts with:
# - Status indicators (📝 draft, 🔒 password-protected, 🌐 live)
# - Word counts
# - Last modified dates
# - Fuzzy search

[Image: The password management interface with colored status output]

📊 Smart Publishing Pipeline

The publishing workflow handles everything:

1. Password Management - Interactive prompts, encrypted storage on server
2. Image Optimization - Automatic WebP conversion with quality controls
3. Multi-Git Deploy - Pushes to both production and GitHub backup
4. Live Preview - Hot-reload development server with instant updates
5. Rollback Support - Git-based versioning means you can always undo

Here’s what a typical publish looks like:

$ ./scripts/publish.sh my-post.md

📝 Publishing: my-post.md
🔍 Validating content...
✅ Front matter valid
✅ No broken links
📦 Building site...
   Started in 12 ms
   Built in 89 ms
🚀 Deploying to production...
   Enumerating objects: 5, done.
   Compressing objects: 100% (3/3), done.
   Writing objects: 100% (3/3), 342 bytes | 342.00 KiB/s, done.
   Total 3 (delta 2), reused 0 (delta 0)
   remote: Stopping caddy...
   remote: Rebuilding site...
   remote: Starting caddy...
✅ Published to https://returnspace.blog
🔄 Backing up to GitHub...
✅ Complete!

📋 Post URL: https://returnspace.blog/p/ea2149b9f8803ccc76d3551f/

[Image: Terminal output showing the colorful deployment progress]

🌍 Cross-Platform Support

Runs seamlessly on macOS, Linux, and WSL2. The scripts automatically detect your platform and use the right tools:

# Platform-agnostic helper functions
sed_inplace() {
    if [[ "$OSTYPE" == "darwin"* ]]; then
        sed -i '' "$@"
    else
        sed -i "$@"
    fi
}

File watching uses fswatch on macOS, inotifywait on Linux. Line endings are enforced via .gitattributes. It just works, everywhere.

📝 Writing Tools Integration

Built-in prose linting with Vale and auto-formatting with Rewrap:

• Vale: Catches passive voice, weasel words, complex sentences—configured for personal blog style, not corporate documentation
• Rewrap: Auto-wraps markdown at 80 characters for readable source files
• Custom Vocabulary: Teach the linter your preferred terms and proper nouns

🎨 Custom CSS That Actually Ships

The design is minimal but intentional. Custom styles for:

/* Code blocks with custom syntax highlighting */
.highlight pre {
    background: #1e1e1e;
    padding: 1.5rem;
    border-radius: 0.5rem;
    overflow-x: auto;
}

/* Responsive tables that don't break on mobile */
table {
    width: 100%;
    border-collapse: collapse;
    overflow-x: auto;
    display: block;
}

/* Typography that's actually readable */
body {
    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
    font-size: 18px;
    line-height: 1.7;
    max-width: 720px;
    margin: 0 auto;
    padding: 2rem 1rem;
}

Every style is hand-tuned. No frameworks. No preprocessors. Just CSS that loads in 8KB and renders instantly.

The Architecture

Tech Stack

The Git Workflow

# Two remotes for different purposes
origin (github)  - Public backup, collaboration
prod (droplet)   - Production deployment

# Publishing pushes to both
git push prod master    # Triggers auto-deploy via git hook
git push github master  # Backup to GitHub

The production server has a post-receive hook that automatically:

1. Stops Caddy
2. Checks out the new code
3. Runs hugo to rebuild the site
4. Starts Caddy
5. Total downtime: <2 seconds

File Organization

returnspace/
├── content/p/        # Published posts (by hash ID)
├── drafts/           # Work in progress
├── scripts/          # 20+ automation scripts
├── layouts/          # Custom Hugo templates
├── static/           # Images, fonts, favicon
└── public/           # Generated static site

No database dumps to manage. No plugin updates to apply. Just files in a Git repo.

The Development Experience

The Scripts

The Aliases

# Install convenient shortcuts
source .blog-aliases

# Now you can:
blog-write note             # Create a draft
post note.md "Post Title"   # Publish draft
blog-edit <slug>            # Edit and deploy a post
blog-preview                # Start dev server
blog-check-deploy           # Watch latest production deploy

Everything is designed to minimize friction. Want to write? Type blog-write and start typing. Want to publish? Use post and it ships in seconds.

Built With AI Assistance

This entire system was designed and built with collaboration from:

• Claude (Anthropic) - Architecture design, script development
• GitHub Copilot - Code completion and suggestions
• ChatGPT o1 - Problem-solving and debugging

80+ commits of iterative development, refactoring, and polish. Features that started as “wouldn’t it be cool if…” became reality through conversation with AI pair programmers.

The scripts are readable, well-commented, and maintainable—because they were written for humans and AI to collaborate on.

Privacy by Design

What ReturnSpace Doesn’t Do

❌ No Google Analytics
❌ No Facebook Pixel
❌ No email capture forms
❌ No cookie banners
❌ No newsletter popups
❌ No algorithmic feed
❌ No “recommended posts”
❌ No social media auto-posting

What It Does Instead

✅ Privacy by obscurity - Posts have hash-based URLs, not SEO-friendly slugs
✅ Manual sharing - You give links to people you want to read your posts
✅ RSS without leaks - Password-protected posts excluded from feed
✅ No tracking - The server logs requests, but that’s it
✅ Your content, your rules - Every post is in your Git repo

The Cost Breakdown

For the price of a single coffee, you get:

• Global CDN
• Unlimited posts
• Unlimited traffic (within reason)
• Password protection
• Custom domain
• No ads, ever

The Future

This is version 1.0, but there’s more to build:

Planned Features

• Comments System - Self-hosted, privacy-friendly discussions
• Image CDN - Optimize and serve images from external storage
• Analytics Dashboard - Privacy-respecting view counts
• Mobile App - Quick publishing from phone
• Federation - Webmentions and IndieWeb protocols

Maybe Someday

• Themes - Swappable design systems
• Plugins - Extensibility without bloat
• Multi-author - Collaborate without complexity

Get Started

ReturnSpace isn’t a SaaS product you can sign up for. It’s a philosophy, a toolkit, and a reference implementation.

The code is yours to fork, modify, and make your own. The scripts are educational. The architecture is documented. Everything is designed to be understood, not obscured.

Want to build your own?

1. Clone or fork the repo
2. Run ./scripts/bootstrap.sh to install dependencies + aliases + hooks
3. Reload your shell (source ~/.zshrc)
4. Launch tui and publish your first post
5. Push to GitHub and run blog-check-deploy to confirm production deploy

No webpack configs. No build pipelines. No framework fatigue.

Just you, your words, and a blog that works exactly how you want it to.

Conclusion

Modern blogging doesn’t have to be complicated. It doesn’t have to track your readers. It doesn’t have to cost $20/month.

ReturnSpace proves that with the right tools and a little creativity, you can build something better than the platforms—something that’s truly yours.

80+ commits. 4,000+ lines of code. Infinite possibilities.

Welcome to blogging on your own terms.

Built with Hugo, hosted on DigitalOcean, cached by Cloudflare, and developed with assistance from Claude, GitHub Copilot, and ChatGPT o1.