Skip to content
Klutch.sh Docs

Deploying Fenrus

Introduction

Fenrus is a modern, self-hosted home dashboard and bookmark manager built with .NET and Blazor. It transforms your browser’s new tab or home page into a powerful, customizable command center for all your web services, applications, and bookmarks. With its clean interface, intelligent app integrations, and real-time status monitoring, Fenrus helps you organize and access your digital life from a single, beautiful dashboard.

Unlike basic bookmark managers or simple link collections, Fenrus provides smart integrations with popular services, displaying live information like download progress, server status, calendar events, and system metrics directly on your dashboard. The application supports multiple users, custom themes, search functionality, and an extensive library of pre-configured app templates that connect seamlessly to services like Sonarr, Radarr, Plex, Home Assistant, and hundreds more.

Perfect for homelab enthusiasts managing multiple services, teams coordinating shared resources, or anyone who wants a personalized start page that does more than just display static links. Fenrus brings intelligence and organization to your browsing experience while keeping all your data private on your own infrastructure.

Key Features

  • Smart App Integrations - Pre-built connectors for 200+ popular services with live status and data display
  • Customizable Dashboard - Drag-and-drop interface to organize apps, groups, and sections
  • Multi-User Support - Individual dashboards and preferences for each user
  • Theme System - Built-in themes with full customization including dark mode support
  • Real-Time Monitoring - Live status updates, health checks, and service availability indicators
  • Search Functionality - Quickly find and launch apps across your entire dashboard
  • Group Management - Organize related services into collapsible groups for better navigation
  • Custom Apps - Add any website or service with custom icons and links
  • Docker Integration - Built-in support for Docker container monitoring and management
  • Guest Access - Share specific dashboards or apps with guests without full access
  • Responsive Design - Works seamlessly on desktop, tablet, and mobile devices
  • Backup/Restore - Export and import dashboard configurations
  • API Access - REST API for programmatic dashboard management
  • Authentication Options - Built-in auth with optional LDAP and OAuth support
  • Lightweight - Minimal resource usage despite rich functionality

Use Cases

Homelab Dashboard: Consolidate access to all your self-hosted services—media servers, download managers, home automation, network monitoring—into one organized interface with live status indicators.

Team Portal: Create a shared dashboard for your team with quick access to internal tools, documentation, monitoring systems, and collaborative services, all organized by department or project.

Personal Start Page: Replace your browser’s default new tab page with a customized dashboard featuring your most-visited sites, productivity tools, and frequently accessed services.

Service Monitoring Hub: Build a centralized monitoring view showing real-time health status of all your services, with immediate visual feedback when something goes down.

Client Dashboard: Provide clients with a branded portal showing status of services you manage for them, documentation links, and support resources, all from your infrastructure.

Development Environment: Organize development tools, staging environments, CI/CD pipelines, and documentation into a single dashboard that streamlines your workflow.

Why Deploy Fenrus on Klutch.sh?

  • Automatic HTTPS - Secure access to your dashboard with automatically provisioned SSL certificates
  • Persistent Storage - Attach volumes to preserve dashboard configurations, themes, and user data across deployments
  • No Server Management - Focus on organizing your services, not maintaining infrastructure
  • Fast Deployments - Get your home dashboard up and running in minutes
  • Environment Variables - Securely configure authentication, API keys, and service connections
  • Resource Scaling - Adjust CPU and memory as your dashboard usage grows
  • Git-Based Updates - Push configuration or theme changes automatically
  • Custom Domains - Use your own domain for a professional dashboard URL
  • Built-in Monitoring - Track resource usage and uptime from the Klutch.sh dashboard
  • Network Access - Connect to other services deployed on Klutch.sh or external infrastructure

Prerequisites

  • A Klutch.sh account
  • Git installed locally
  • Basic understanding of .NET applications (helpful but not required)
  • Optional: Services you want to integrate (Sonarr, Radarr, Plex, etc.)

Understanding Fenrus Architecture

Fenrus operates as a server-side Blazor application with the following components:

  1. Web Server: ASP.NET Core hosts the Blazor application on HTTP
  2. Data Layer: SQLite database stores dashboard configurations, user settings, and app data
  3. App System: Modular system for integrating with external services via APIs
  4. Theme Engine: Customizable CSS-based theming system
  5. User Management: Built-in authentication with role-based access control
  6. Background Workers: Periodic health checks and status updates for connected apps

Preparing Your Repository

Step 1: Create Project Structure

Create a new directory for your Fenrus deployment:

Terminal window
mkdir fenrus-deployment
cd fenrus-deployment

Step 2: Create the Dockerfile

Create a production-ready Dockerfile for Fenrus:

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build


# Set working directory
WORKDIR /src


# Clone Fenrus repository
RUN apt-get update && apt-get install -y git && \
    git clone https://github.com/revenz/Fenrus.git .


# Restore dependencies
WORKDIR /src/Fenrus
RUN dotnet restore


# Build the application
RUN dotnet publish -c Release -o /app/publish


FROM mcr.microsoft.com/dotnet/aspnet:8.0


# Install curl for health checks
RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*


# Create app user
RUN useradd -m -u 1001 appuser


# Set working directory
WORKDIR /app


# Copy published application
COPY --from=build /app/publish .


# Create data directory
RUN mkdir -p /app/data && \
    chown -R appuser:appuser /app


# Switch to non-root user
USER appuser


# Expose the application port
EXPOSE 3000


# Set environment variables
ENV ASPNETCORE_URLS=http://+:3000
ENV ASPNETCORE_ENVIRONMENT=Production
ENV Fenrus__DataPath=/app/data


# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
  CMD curl -f http://localhost:3000/health || exit 1


# Start the application
ENTRYPOINT ["dotnet", "Fenrus.dll"]

Step 3: Create Configuration File

Create appsettings.Production.json for production configuration:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "Fenrus": {
    "DataPath": "/app/data",
    "EnableGuests": true,
    "AllowRegistration": true,
    "DefaultTheme": "Default",
    "CheckForUpdates": false,
    "TelemetryEnabled": false
  },
  "AllowedHosts": "*",
  "Kestrel": {
    "Endpoints": {
      "Http": {
        "Url": "http://0.0.0.0:3000"
      }
    }
  }
}

Step 4: Create Environment Variables Template

Create .env.example:

Terminal window
# Server Configuration
ASPNETCORE_URLS=http://+:3000
ASPNETCORE_ENVIRONMENT=Production


# Fenrus Configuration
Fenrus__DataPath=/app/data
Fenrus__EnableGuests=true
Fenrus__AllowRegistration=true
Fenrus__DefaultTheme=Default


# Security (Optional)
Fenrus__RequireHttps=false
Fenrus__AdminPassword=


# External Service Integration (Examples)
# Fenrus__Apps__Sonarr__ApiKey=your-sonarr-api-key
# Fenrus__Apps__Radarr__ApiKey=your-radarr-api-key
# Fenrus__Apps__Plex__Token=your-plex-token

Step 5: Create README

Create README.md:

# Fenrus Dashboard


Modern home dashboard for organizing and monitoring your services.


## Features


- Customizable dashboard with drag-and-drop interface
- 200+ pre-built app integrations
- Multi-user support with individual dashboards
- Real-time status monitoring
- Custom themes including dark mode
- Mobile-friendly responsive design


## Deployment


Deploy to Klutch.sh for automatic scaling and management.


## Configuration


All dashboard configuration is managed through the web interface after deployment.


### Adding Apps


1. Log in to your dashboard
2. Click "Add App" or edit mode
3. Select from pre-built templates or add custom app
4. Configure app settings and API credentials
5. Save and position on your dashboard


### Custom Themes


Themes can be customized through Settings > Appearance:
- Choose from built-in themes
- Customize colors, fonts, and spacing
- Upload custom CSS for advanced styling
- Set per-user theme preferences


## Data Storage


Dashboard data is stored in SQLite at `/app/data`:
- `fenrus.db` - Dashboard configuration and user data
- `themes/` - Custom theme files
- `icons/` - Custom app icons
- `backups/` - Automatic backup files

Step 6: Create .gitignore

Terminal window
# Application data
data/
*.db
*.db-shm
*.db-wal


# Logs
logs/
*.log


# Environment variables
.env


# System files
.DS_Store
Thumbs.db


# IDE
.vscode/
.idea/
*.swp
*.swo

Step 7: Create docker-compose.yml for Local Development

version: '3.8'


services:
  fenrus:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - fenrus-data:/app/data
    environment:
      - ASPNETCORE_URLS=http://+:3000
      - ASPNETCORE_ENVIRONMENT=Development
      - Fenrus__DataPath=/app/data
      - Fenrus__EnableGuests=true
      - Fenrus__AllowRegistration=true
    restart: unless-stopped


volumes:
  fenrus-data:

Step 8: Initialize Git Repository

Terminal window
git init
git add .
git commit -m "Initial Fenrus deployment setup"

Push to your GitHub repository:

Terminal window
git remote add origin https://github.com/yourusername/fenrus-deployment.git
git branch -M main
git push -u origin main

Deploying on Klutch.sh

  1. Log in to Klutch.sh
    Navigate to klutch.sh/app and sign in to your account.
  2. Create a New App
    Click New App and select Deploy from GitHub. Choose your Fenrus repository.
  3. Configure Build Settings
    Klutch.sh will automatically detect your Dockerfile. No additional build configuration is needed.
  4. Set Traffic Type
    Select HTTP traffic since Fenrus serves a web interface. The internal port should be set to 3000.
  5. Configure Environment Variables
    Add the following environment variables:
    • ASPNETCORE_URLS = http://+:3000
    • ASPNETCORE_ENVIRONMENT = Production
    • Fenrus__DataPath = /app/data
    • Fenrus__EnableGuests = true (optional)
    • Fenrus__AllowRegistration = true (set to false after creating admin account)
  6. Attach Persistent Volume
    To preserve dashboard data and configurations:
    • In the Volumes section, click Add Volume
    • Set mount path: /app/data
    • Set size: 5GB (adjust based on expected usage)
  7. Deploy the App
    Click Deploy. Klutch.sh will build your Docker image and start your Fenrus instance. The initial build may take 5-10 minutes as it compiles the .NET application.
  8. Verify Deployment
    Once deployed, visit https://example-app.klutch.sh (replace with your actual app URL) to access your Fenrus dashboard.
  9. Create Admin Account
    On first visit, click Register to create your admin account. This will be the primary account for managing the dashboard.
  10. Configure Your Dashboard
    Start adding apps by clicking the + Add App button. Select from pre-built templates or create custom links.

Post-Deployment Configuration

Initial Setup

After deploying Fenrus, complete the following setup steps:

  1. Create Admin Account: Register immediately to become the administrator
  2. Disable Registration: Set Fenrus__AllowRegistration=false after creating all needed accounts
  3. Configure Theme: Go to Settings → Appearance to select or customize your theme
  4. Add First Apps: Start with frequently accessed services or bookmarks

Dashboard Organization

Creating Groups: Groups help organize related services together.

  1. Click Edit Mode (pencil icon)
  2. Click Add Group
  3. Name your group (e.g., “Media”, “Home Automation”, “Development”)
  4. Drag apps into groups
  5. Set group to collapsed or expanded by default
  6. Save your changes

Adding Apps: Fenrus supports two types of apps:

Smart Apps (with integrations):

1. Click "Add App"
2. Search for your service (e.g., "Sonarr")
3. Enter service URL and API key
4. Test connection
5. Position on dashboard
6. Save

Custom Links:

1. Click "Add App"
2. Select "Custom Link"
3. Enter URL, title, and description
4. Upload or select icon
5. Position on dashboard
6. Save

App Configuration Examples

Sonarr Integration:

{
  "url": "https://sonarr.example.com",
  "apiKey": "your-sonarr-api-key",
  "displayOptions": {
    "showQueueCount": true,
    "showMissingEpisodes": true,
    "refreshInterval": 300
  }
}

Radarr Integration:

{
  "url": "https://radarr.example.com",
  "apiKey": "your-radarr-api-key",
  "displayOptions": {
    "showQueueCount": true,
    "showMissingMovies": true,
    "refreshInterval": 300
  }
}

Plex Integration:

{
  "url": "https://plex.example.com",
  "token": "your-plex-token",
  "displayOptions": {
    "showRecentlyAdded": true,
    "showCurrentStreams": true,
    "refreshInterval": 60
  }
}

Home Assistant Integration:

{
  "url": "https://homeassistant.local",
  "token": "your-ha-token",
  "displayOptions": {
    "showEntities": true,
    "entityIds": ["sensor.temperature", "light.living_room"],
    "refreshInterval": 30
  }
}

User Management

Adding Users:

  1. Go to Settings → Users
  2. Click Add User
  3. Enter username, email, and password
  4. Assign role (Admin or User)
  5. Save

User Roles:

  • Admin: Full access to all settings and all users’ dashboards
  • User: Can only manage their own dashboard and settings

Guest Access: Enable guests to view dashboards without accounts:

Terminal window
Fenrus__EnableGuests=true

Create a guest-accessible dashboard:

  1. Create a dedicated user account
  2. Configure their dashboard
  3. Share the guest URL: https://example-app.klutch.sh/guest/username

Theme Customization

Built-in Themes

Fenrus includes several themes:

  • Default: Clean light theme
  • Dark: Dark mode with blue accents
  • Nord: Popular Nord color palette
  • Dracula: Dracula theme port
  • Gruvbox: Retro gruvbox colors
  • Catppuccin: Modern pastel theme

Change theme:

  1. Go to Settings → Appearance
  2. Select theme from dropdown
  3. Preview changes in real-time
  4. Save

Custom CSS

Add custom styling:

  1. Go to Settings → Appearance → Custom CSS
  2. Add your CSS rules:
/* Custom dashboard styling */
:root {
  --primary-color: #3b82f6;
  --background-color: #1e293b;
  --card-background: #334155;
  --text-color: #f1f5f9;
}


/* Custom card hover effect */
.app-card:hover {
  transform: translateY(-5px);
  box-shadow: 0 10px 25px rgba(0, 0, 0, 0.3);
  transition: all 0.3s ease;
}


/* Custom group headers */
.group-header {
  background: linear-gradient(90deg, var(--primary-color), transparent);
  border-left: 4px solid var(--primary-color);
  padding-left: 12px;
}
  1. Save and refresh to see changes

Logo and Branding

Customize branding:

  1. Go to Settings → Appearance → Branding
  2. Upload custom logo (recommended: 200x50px PNG)
  3. Set dashboard title
  4. Configure favicon
  5. Save changes

Advanced Configuration

Search Configuration

Enable and configure search:

Terminal window
# Enable search
Fenrus__EnableSearch=true


# Search settings
Fenrus__Search__MinCharacters=2
Fenrus__Search__MaxResults=10
Fenrus__Search__IncludeGroups=true

Using search:

  • Press / to open search
  • Type app name or URL
  • Press Enter to launch
  • Press Esc to close

Backup and Restore

Automatic Backups: Fenrus creates automatic backups in /app/data/backups/:

  • Daily backups retained for 7 days
  • Weekly backups retained for 4 weeks
  • Monthly backups retained for 6 months

Manual Backup:

Terminal window
# Export dashboard configuration
1. Go to Settings → Backup
2. Click "Export Configuration"
3. Save JSON file locally

Restore from Backup:

Terminal window
1. Go to Settings → Backup
2. Click "Import Configuration"
3. Upload backup JSON file
4. Confirm restore
5. Refresh dashboard

Database Backup (via persistent volume): Since data is stored in /app/data, regular volume backups preserve all configuration.

API Usage

Fenrus provides a REST API for programmatic management:

Authentication:

Terminal window
# Get API token
curl -X POST https://example-app.klutch.sh/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{
    "username": "admin",
    "password": "your-password"
  }'

List Apps:

Terminal window
curl https://example-app.klutch.sh/api/apps \
  -H "Authorization: Bearer YOUR_TOKEN"

Add App:

Terminal window
curl -X POST https://example-app.klutch.sh/api/apps \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "New Service",
    "url": "https://service.example.com",
    "icon": "custom-icon.png",
    "groupId": 1
  }'

Update App:

Terminal window
curl -X PUT https://example-app.klutch.sh/api/apps/1 \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Updated Service",
    "url": "https://newurl.example.com"
  }'

Delete App:

Terminal window
curl -X DELETE https://example-app.klutch.sh/api/apps/1 \
  -H "Authorization: Bearer YOUR_TOKEN"

Docker Container Monitoring

Monitor Docker containers directly from Fenrus:

  1. Enable Docker Integration:
Terminal window
# Mount Docker socket in Dockerfile (for local development only)
# For Klutch.sh, use Docker API endpoint instead
Fenrus__Docker__Enabled=true
Fenrus__Docker__Endpoint=tcp://docker-host:2375
  1. Add Docker Containers as Apps:
{
  "type": "docker",
  "container": "container-name",
  "displayOptions": {
    "showStatus": true,
    "showStats": true,
    "allowControl": true
  }
}
  1. Monitor Container Health:
  • Green indicator: Container running
  • Red indicator: Container stopped
  • Yellow indicator: Container unhealthy

External Service Integrations

Popular Integrations:

Media Management:

  • Sonarr, Radarr, Lidarr, Readarr
  • Plex, Jellyfin, Emby
  • Overseerr, Ombi
  • Tautulli

Download Managers:

  • qBittorrent, Transmission, Deluge
  • SABnzbd, NZBGet
  • Aria2

Home Automation:

  • Home Assistant
  • OpenHAB
  • Node-RED

Monitoring:

  • Uptime Kuma
  • Grafana
  • Prometheus
  • Netdata

Development:

  • GitLab, Gitea, Gogs
  • Jenkins, Drone CI
  • Portainer
  • Traefik

Each integration requires:

  1. Service URL
  2. API key or token (found in service settings)
  3. Appropriate network access between Fenrus and service

Production Best Practices

Security

  • Disable Registration - Set Fenrus__AllowRegistration=false after creating all necessary accounts
  • Strong Passwords - Enforce strong passwords for all user accounts
  • HTTPS Only - Klutch.sh provides automatic HTTPS; ensure all external service URLs use HTTPS
  • API Key Security - Store API keys in environment variables, not in dashboard configuration
  • Guest Access Control - Limit guest access to specific dashboards with non-sensitive information
  • Regular Updates - Keep Fenrus updated by rebuilding with latest image
  • Access Logging - Enable logging to track dashboard access and changes

Performance

  • Refresh Intervals - Set reasonable refresh intervals for apps (300 seconds minimum for most services)
  • Limit Apps - Keep dashboard focused; avoid adding 100+ apps per dashboard
  • Optimize Icons - Use optimized images for custom icons (max 512x512px)
  • Group Organization - Use groups and collapse less-used sections
  • Database Maintenance - Fenrus automatically maintains SQLite database
  • Cache Configuration - Fenrus caches app data; adjust cache TTL in settings

Monitoring

  • Health Checks - Klutch.sh monitors health endpoint automatically
  • Resource Usage - Monitor CPU and memory in Klutch.sh dashboard
  • App Status - Review app connection status in Fenrus dashboard
  • Error Logs - Check application logs for integration errors
  • Backup Verification - Regularly verify automatic backups are created

Scaling

  • User Growth - Fenrus handles 100+ users on modest resources
  • App Connections - Each app integration adds minimal overhead
  • Resource Allocation - Default: 512MB RAM, 0.5 CPU cores sufficient
  • Storage Growth - Database grows slowly; 1GB sufficient for most use cases
  • Horizontal Scaling - Not recommended due to SQLite; consider PostgreSQL for large deployments

Troubleshooting

Dashboard Not Loading

Issue: Dashboard shows blank page or loading spinner indefinitely.

Solutions:

  • Check application logs in Klutch.sh dashboard
  • Verify environment variables are set correctly
  • Ensure persistent volume is mounted at /app/data
  • Check that port 3000 is configured correctly
  • Clear browser cache and cookies
  • Try accessing in incognito/private browsing mode

App Integration Not Working

Issue: Smart app shows “Connection Failed” or no data.

Solutions:

  • Verify service URL is accessible from Fenrus container
  • Check API key is correct and has necessary permissions
  • Ensure service API is enabled in service settings
  • Test service URL directly in browser
  • Check if service requires specific network access or authentication
  • Review Fenrus logs for detailed error messages
  • Increase refresh interval if service is rate-limiting

Can’t Create Admin Account

Issue: Registration page not appearing or errors on account creation.

Solutions:

  • Verify Fenrus__AllowRegistration=true is set
  • Check persistent volume is writable
  • Ensure database directory permissions are correct (user 1001)
  • Delete /app/data/fenrus.db to start fresh (loses all data)
  • Check logs for SQLite errors

Theme Not Applying

Issue: Custom CSS or theme changes not visible.

Solutions:

  • Hard refresh browser (Ctrl+Shift+R or Cmd+Shift+R)
  • Clear browser cache completely
  • Check custom CSS for syntax errors
  • Verify theme file is saved in /app/data/themes/
  • Try switching to different theme first, then back
  • Check browser console for CSS loading errors

High Memory Usage

Issue: Fenrus container using excessive memory.

Solutions:

  • Reduce number of apps with real-time updates
  • Increase refresh intervals for apps (600+ seconds)
  • Disable apps that are rarely used
  • Check for app integrations with memory leaks
  • Restart container to clear memory
  • Review logs for repeated errors or warnings

Database Corruption

Issue: Fenrus fails to start with database errors.

Solutions:

  • Restore from automatic backup in /app/data/backups/
  • Run SQLite integrity check: sqlite3 fenrus.db "PRAGMA integrity_check"
  • Export dashboard configuration and recreate database
  • Check persistent volume for disk space and health
  • Ensure proper shutdown procedures (no forced kills)

Guest Access Not Working

Issue: Guest URL returns 404 or shows login page.

Solutions:

  • Verify Fenrus__EnableGuests=true is set
  • Ensure user account for guest access exists
  • Check guest URL format: /guest/username
  • Restart application after enabling guest access
  • Verify user has at least one app on their dashboard

Example Dashboard Configurations

Media Server Dashboard

Perfect for organizing media services:

Groups:

  1. Media Servers: Plex, Jellyfin, Emby
  2. Content Management: Sonarr, Radarr, Lidarr
  3. Download Clients: qBittorrent, SABnzbd
  4. Requests: Overseerr, Ombi
  5. Monitoring: Tautulli, Bazarr

Configuration:

{
  "theme": "Dark",
  "layout": "grid",
  "columns": 4,
  "showGroupHeaders": true,
  "autoCollapse": false,
  "refreshInterval": 300
}

Homelab Management Dashboard

For managing self-hosted infrastructure:

Groups:

  1. System: Proxmox, Portainer, Cockpit
  2. Monitoring: Grafana, Uptime Kuma, Netdata
  3. Home Automation: Home Assistant, Node-RED
  4. Network: Pi-hole, AdGuard, Traefik
  5. Backup: Duplicati, Restic, Proxmox Backup

Configuration:

{
  "theme": "Nord",
  "layout": "list",
  "showStatus": true,
  "alertOnDown": true,
  "refreshInterval": 60
}

Development Tools Dashboard

For development team collaboration:

Groups:

  1. Code: GitLab, Gitea, GitHub
  2. CI/CD: Jenkins, Drone, GitLab CI
  3. Documentation: Wiki.js, BookStack, Outline
  4. Monitoring: Sentry, Grafana, Prometheus
  5. Communication: Mattermost, Rocket.Chat

Configuration:

{
  "theme": "Gruvbox",
  "layout": "grid",
  "columns": 3,
  "enableSearch": true,
  "showRecentActivity": true
}

Personal Productivity Dashboard

For individual use and productivity:

Groups:

  1. Frequent Sites: Gmail, Calendar, Drive
  2. News: RSS feeds, Reddit, Hacker News
  3. Tools: Password manager, Notes, Tasks
  4. Learning: Udemy, YouTube, Documentation
  5. Entertainment: Streaming services, Music

Configuration:

{
  "theme": "Catppuccin",
  "layout": "grid",
  "columns": 5,
  "showIcons": true,
  "compactMode": false
}

Migration and Import

From Homer Dashboard

Import Homer configuration:

  1. Export Homer config as YAML
  2. Convert YAML to JSON
  3. Create script to map Homer apps to Fenrus format
  4. Import via API or manual creation

Example conversion:

// Homer service
{
  "name": "Radarr",
  "logo": "assets/radarr.png",
  "url": "https://radarr.example.com",
  "tag": "media"
}


// Fenrus equivalent
{
  "name": "Radarr",
  "type": "radarr",
  "url": "https://radarr.example.com",
  "apiKey": "YOUR_API_KEY",
  "groupName": "media"
}

From Heimdall

Heimdall uses MySQL; export data:

-- Export Heimdall apps
SELECT title, url, description, icon
FROM applications;

Convert to Fenrus format and import via API.

From Organizr

Export Organizr tabs and convert to Fenrus groups:

  1. List all Organizr tabs
  2. Map tabs to Fenrus groups
  3. Convert tab items to Fenrus apps
  4. Import configuration

From Browser Bookmarks

Import browser bookmarks as custom links:

  1. Export bookmarks as HTML
  2. Parse HTML to extract URLs and titles
  3. Create Fenrus apps via API
  4. Organize into appropriate groups

Additional Resources

You now have a production-ready Fenrus dashboard deployed on Klutch.sh! Customize your dashboard, add your services, and enjoy having all your web applications organized in one beautiful interface. For questions or issues, check the troubleshooting section or reach out to the Klutch.sh community.