Rackula

Open-source server rack visualization, honestly reviewed. No marketing copy, just what you actually get.

TL;DR

• What it is: A free, open-source drag-and-drop rack layout visualizer. You plan your server rack in a browser, export it as PNG/PDF/SVG, and share it via a QR code or URL — no account required [1][3].
• Who it’s for: Homelab builders, IT administrators, and data center planners who are tired of doing rack layouts in Excel, Visio, or draw.io. Not a tool for non-technical users; requires at least basic comfort with physical infrastructure [1][2].
• Cost: $0. The hosted version at count.racku.la is free. Self-hosting is free plus VPS costs. There is no paid tier [README].
• Key strength: Real device images pulled from a library compatible with NetBox’s devicetype-library, proper U-height scaling, and a genuinely clean interface — it looks like your actual gear, not generic placeholder boxes [1][3].
• Key weakness: Authentication is still being built out — local auth mode is listed as in-progress in the README, and OIDC wiring is incomplete. For a tool you’d expose on a network, this matters [README].

---

What is Rackula

Rackula is a browser-based rack layout designer. You pick your rack type and size, drag devices from a library into the rack, see the result as an accurate elevation diagram with front and back views, and export or share it. That’s the whole pitch.

The README is refreshingly direct: “Plan your rack layout. Drag your devices in, move them around, export it. It runs in your browser. You can close the tab whenever you want.” [README] No vendor-speak, no roadmap promises, no “AI-powered” nonsense. It does one thing and describes that thing honestly.

The project is built with TypeScript and Svelte [1][2] and sits at 924 GitHub stars as of this writing [merged profile]. It’s MIT licensed, meaning you can self-host it, embed it in internal tooling, or fork it without legal complications [README]. The project was flagged by Self-Host Weekly in January 2026 as using AI in its development process [4] — worth knowing for teams that care about code provenance, though it doesn’t affect functionality.

There’s a hosted version at https://count.racku.la that requires no account and stores your layout in the URL itself. Self-hosting adds persistent storage through a two-container Docker setup: one container for the frontend and one for the API backend [1][2][README].

---

Why people choose it

The short answer: nothing else in the free/open-source category does what Rackula does with this level of polish.

The traditional alternatives are painful in different ways. Draw.io and Lucidchart require you to build rack visuals manually from shapes — there’s no device library, no U-height awareness, and you’ll spend more time fighting the diagramming tool than thinking about your layout. Visio is expensive and Windows-only. Spreadsheets work but produce zero-visual output useful for documentation. The professional DCIM platforms — Sunbird dcTrack, nlyte, Racktivity — are enterprise software with enterprise pricing that makes no sense for a homelab or a 5-rack deployment.

GIGAZINE’s walkthrough [3] captures why Rackula hits differently: you open it, click “New Rack,” choose your rack dimensions from a sensible set of options (Standard 19-inch, Half-width 10-inch, Broadcast 21-inch, or Telecom 23-inch, up to 100U), and within minutes you’re dragging actual server images into positions and looking at something that resembles your real rack. The device library is organized by brand, category, or alphabetically, uses images compatible with NetBox’s devicetype-library [1][2], and displays height and depth information before you place anything.

Marius Hosting’s deployment guides [1][2] — which between the UGREEN NAS and Synology NAS versions represent probably the largest community of documented installs — frame the appeal clearly: this is the tool you set up once on your NAS and then point your whole homelab documentation process at. The QR code sharing means you can print a rack diagram, pin it to the server room wall, and have anyone scan it to get the interactive layout.

Self-Host Weekly noted the v0.7.0 release in January 2026 as adding multi-rack support and persistent storage [4], which addressed the two most commonly cited gaps from the stateless early version.

---

Features

Based on the README and GIGAZINE’s hands-on walkthrough [3]:

Rack creation and configuration:

• Column layout (single rack, 1–42U standard, up to 100U custom) and Bayed layout (2–3 parallel columns, 10–24U) [3]
• Rack widths: Half (10”), Standard (19”), Broadcast (21”), Telecom (23”) [3]
• Unit numbering direction (U1 at top or bottom) [3]
• Front and rear view — half-depth devices can be placed independently on front and back [3]
• Notes field and annotation display on the diagram [3]
• Multi-rack support as of v0.7.0 [4]

Device library:

• Real device images, compatible with NetBox’s devicetype-library [1][2]
• Browse by brand, category, or alphabetically [3]
• Height (U count), special widths, and depths displayed in the library before placement [3]
• Generic device options when your specific hardware isn’t listed [3]

Editing:

• Drag-and-drop placement and rearrangement [README]
• Undo/redo [3]
• Display modes: label only, diagram only, diagram + label [3]

Sharing and export:

• Export to PNG, PDF, SVG [README][1]
• QR code sharing [README]
• Stateless mode: layout encoded in the URL itself, no account needed [1][README]

Self-hosting extras:

• Persistent storage via volume-mounted API container [README][1]
• REST API with optional write token protection (RACKULA_API_WRITE_TOKEN) [README]
• Auth gate with OIDC or local modes (see deployment section for caveats) [README]
• CORS_ORIGIN restriction for API access [README]

---

Pricing: SaaS vs self-hosted math

This section is simpler than usual: Rackula doesn’t have paid tiers.

Hosted (count.racku.la): Free, no account, no limits stated. Your layout lives in the URL. The trade-off is no persistence between sessions unless you save the URL or export the file [README].

Self-hosted: Free software (MIT). You pay for the server it runs on.

The relevant cost comparison isn’t between Rackula tiers — it’s between Rackula and the alternatives people actually use:

• Lucidchart: Free tier is heavily limited; paid plans start around $9/user/month. No rack-aware device library, no U-height calculation.
• Enterprise DCIM (Sunbird, nlyte): Pricing is not public and requires a sales call — this is software designed for large data centers with budgets to match. Not a realistic option for homelab or small-business use.
• Draw.io: Free, but building rack diagrams manually from shapes is friction with no payoff.
• Spreadsheets: Free, produces zero visual output.

For anyone with an existing homelab NAS (the Marius Hosting guides target exactly this scenario [1][2]), the self-hosted deployment runs as two Docker containers alongside everything else. No dedicated VPS needed unless you’re spinning something up from scratch, in which case a $5/mo Hetzner VPS is the floor.

The honest cost of Rackula is your time to deploy and maintain it, not money. For the hosted version, the cost is zero and the only downside is trusting count.racku.la to stay online.

---

Deployment reality check

The Marius Hosting guides [1][2] — written for NAS users — are the best signal for deployment complexity because they’re written for people who are comfortable with Docker but not necessarily with Linux administration. The fact that Marius can write a step-by-step NAS guide for it (rather than punting to “hire a sysadmin”) tells you the complexity ceiling is manageable.

Standard setup (stateless, no persistence):

docker run -d -p 8080:8080 ghcr.io/rackulalives/rackula:latest

One command. Open http://localhost:8080 and you’re building layouts. This works for personal use where you save the exported files or save the URL [README].

Persistent storage setup (two containers):

The persistent version runs rackula (frontend) and rackula-api (backend) as separate containers. The Marius Hosting docker-compose examples [1][2] add one wrinkle: you need to set the UID/GID for the API container to match your NAS user, otherwise the volume permissions won’t work. That’s a one-time lookup, not a recurring headache.

Authentication — the honest assessment:

The README is unusually candid here: “OIDC/local login provider wiring is still in progress” [README]. The auth gate exists and has security hardening (HttpOnly cookies, SameSite, CSRF enforcement, session rotation), but:

• none mode: auth gate disabled — fine for local/trusted networks only [README]
• oidc: works, requires an external OIDC provider (Authentik, Keycloak, etc.) plus additional config [README]
• local: tracked in issue #1117, not yet stable [README]

If you’re deploying this on a public IP without a VPN in front of it, today’s auth situation means you’re either setting up OIDC (which has its own complexity) or accepting that write access is controlled only by the RACKULA_API_WRITE_TOKEN environment variable. That’s enough for trusted-network use, not enough for internet-exposed deployment without additional hardening.

Realistic setup time:

• Stateless, local use: 5 minutes
• Persistent, NAS deployment: 20–45 minutes following the Marius Hosting guides [1][2]
• Persistent with OIDC: 1–2 hours including OIDC provider setup
• Realistic for a first-time self-hoster: budget an afternoon if you’ve never touched Docker volumes before

---

Pros and Cons

Pros

• Real device images, proper scale. This is what separates Rackula from drawing rectangles in draw.io. The library uses NetBox-compatible device images [1][2], so your Cisco switch looks like your Cisco switch, not a placeholder [3].
• URL-based stateless sharing. Your layout is in the URL. QR code it, email it, print it. No “you need an account to view this” friction [README][1].
• Zero cost. MIT license, hosted version free, self-hosted version free. No free tier with a paid upgrade prompt anywhere [README].
• Front and back views. Half-depth devices can be placed independently on both faces — relevant for anyone mixing patch panels, cable management, and compute [3].
• Docker in one command. The stateless version genuinely takes minutes to run [README]. The persistent version is two containers and a volume mount.
• Active development. Multi-rack support and persistent storage landed in v0.7.0 [4]; v0.9.3 was the current release at time of the Marius Hosting guides [1][2].
• NetBox-compatible device library. If your organization already runs NetBox, the device images and library format are familiar [1][2].

Cons

• Auth is incomplete. Local auth mode is still in-progress per the README and issue tracker [README]. For internet-exposed deployments, you’re limited to OIDC or raw API token protection today.
• No database browsing UI. Rackula doesn’t have a management interface for your stored layouts beyond the main app — you’re working with a file-backed API, and inspecting or bulk-managing saved layouts requires direct file access.
• Small project, one maintainer risk. 924 stars is healthy for a niche tool [merged profile], but this isn’t a large open-source organization. If the maintainer loses interest, the project’s future depends on the community forking it.
• Device library gaps. The library pulls from the NetBox devicetype-library community, which is comprehensive for common enterprise gear but may be missing your specific obscure switch or custom 1U appliance. The fallback is “Generic” device types, which gets you placeholder boxes [3].
• No multi-user collaboration. Layouts are either URL-based (single session) or stored per-instance. There’s no concept of shared workspaces, comments, or version history beyond undo/redo within a session [README].
• Bayed rack limits. The Bayed layout option tops out at 24U per bay [3], which may not cover larger multi-bay configurations.
• AI-assisted development. Self-Host Weekly flagged the project as using AI in development [4]. This isn’t inherently a problem, but teams with strict code provenance requirements should know.

---

Who should use this / who shouldn’t

Use Rackula if:

• You’re building or documenting a homelab rack and you’ve been putting off laying it out because the alternatives are too tedious.
• You’re an IT admin at a small-to-medium organization who needs to produce rack documentation for audits, handoffs, or vendor conversations without purchasing DCIM software.
• You run a Synology, UGREEN, or any Docker-capable NAS and want the persistent version running alongside your other self-hosted services [1][2].
• You need to share rack diagrams with non-technical stakeholders — the QR code + URL sharing is genuinely useful for this [README].
• You already run NetBox and want a visual layout tool that uses the same device library [1][2].

Skip it if:

• You need full DCIM functionality — power monitoring, cable management tracking, capacity planning, environmental sensors. Rackula is visualization only. Enterprise tooling exists for the rest.
• You need internet-facing deployment with simple username/password auth today. The local auth mode isn’t ready [README].
• Your rack uses a lot of uncommon or custom hardware that won’t be in the NetBox devicetype-library.
• You need multi-user real-time collaboration on rack designs. This isn’t that tool.

---

Alternatives worth considering

• NetBox — the obvious comparison in the self-hosted DCIM space. NetBox is a full infrastructure documentation platform: it tracks IP addresses, vlans, cables, power, and rack layouts. The rack visualization in NetBox is less interactive than Rackula’s drag-and-drop, but the platform does vastly more. If you need asset tracking alongside layout design, NetBox is the answer — and Rackula’s device library is compatible with it [1][2]. The catch is deployment complexity: NetBox requires PostgreSQL, Redis, and more configuration than Rackula.
• RackTables — older PHP-based rack management system. Still maintained but the interface hasn’t kept pace. Worth knowing it exists if you need something more database-driven than Rackula.
• Draw.io / Lucidchart — general diagramming tools. Free (draw.io) or low-cost. No rack-aware device library, no U-height awareness, but more flexible for non-standard layouts and already installed in many orgs. Use these if your rack is unusual and you’re happy building visuals by hand.
• Rack Studio (by Racktivity) and other commercial options — exist but come with enterprise pricing and the usual vendor lock-in. Not realistic for homelab or small deployments.
• Plain spreadsheet — laugh if you want, but a 42-row spreadsheet with conditional formatting is still how a lot of homelabs document their racks. Zero deployment overhead; zero visual value.

For most homelab users, the realistic choice is Rackula vs. draw.io. Pick Rackula if you want accurate visuals with real device images and proper U-height scaling. Pick draw.io if you need more layout flexibility or already have it in your workflow.

---

Bottom line

Rackula solves one specific problem well: making a rack layout that actually looks like a rack. The device library, the scaling, the front/back views, the URL-based sharing — these are the right design choices for the use case, and the result is a tool that’s genuinely faster to use than any free alternative. The cost is zero, the MIT license is clean, and the Docker deployment is straightforward.

The caveats are real: authentication is still being hardened, the project is small, and it doesn’t pretend to be anything beyond a visual planning and documentation tool. If you need full DCIM, Rackula is not it. But if you’ve been putting off documenting your rack because draw.io is tedious and NetBox is overkill, Rackula is the gap-filler you were looking for.

---

Sources

1. Marius Hosting — “How to Install Rackula on Your UGREEN NAS”. https://mariushosting.com/how-to-install-rackula-on-your-ugreen-nas/
2. Marius Hosting — “How to Install Rackula on Your Synology NAS”. https://mariushosting.com/how-to-install-rackula-on-your-synology-nas/
3. GIGAZINE — “Rackula is a free drag-and-drop server rack layout solution that can also be self-hosted” (Feb 22, 2026). https://gigazine.net/gsc_news/en/20260222-rackula/
4. Ethan Sholly, Self-Host Weekly — “Self-Host Weekly (30 January 2026)”. https://selfh.st/weekly/2026-01-30/

Primary sources:

• GitHub repository and README: https://github.com/rackulalives/rackula (924 stars, MIT license)
• Official hosted instance: https://count.racku.la