LiveChat 
Support 
How to Make and Use a Custom Map for a Rust Dedicated Server
Running a custom map is one of the fastest ways to make a Rust server feel different from every other server in the browser. You have two practical routes: tune a custom procedural map with a seed and world size, or load a fully hand-made map built in a third-party editor and exported as a `.map` file. Both are achievable on any properly resourced Rust dedicated server, and the difference between them is mostly about effort versus control.
This guide walks through both options, the exact server config lines you need, and the one detail that trips up most first-time admins: how a hand-made `.map` file actually reaches your server and players.
Key Takeaways
• A custom procedural map is the easy path: set `server.seed` and `server.worldsize` and the server generates a unique world on boot.
• A hand-made map is built in the RustEdit editor and exported as a `.map` file for full control over monuments and terrain.
• You do not upload a `.map` file directly to the server. You host it at a public direct-download URL and point `server.levelurl` at it.
• Connecting clients download the map from that same URL, so reliable file hosting and bandwidth matter as much as the config.
• Custom-map features and monuments often require the Oxide/uMod plugin framework installed alongside the map.
What counts as a custom map in Rust?
In Rust, “custom map” covers two very different things, and knowing which one you want decides everything that follows.
A custom procedural map is still a generated world, but you control its inputs. Rust builds the terrain, biomes, and monuments from a numeric seed and a world size. Change either value and you get a completely different — but still procedurally generated — landscape. This is technically custom, and it is the lowest-effort option because Rust does all the heavy lifting at server startup.
A hand-made custom map is a world someone designed by hand. Terrain, roads, monument placement, custom prefabs, and points of interest are all arranged deliberately in an editor, then exported as a single `.map` file. This is what people usually mean by a “custom map” when they share download links or showcase unique builds.
The key mental split: designing the map is a creative task; getting it onto the server is a hosting and configuration task. This guide focuses on the second part, because that is where hosting decisions and config lines come in.
Procedural vs editor-made maps at a glance
| Aspect | Custom procedural map | Hand-made (editor) map |
|---|---|---|
| How it’s created | `server.seed` + `server.worldsize` | Designed in RustEdit, exported as `.map` |
| Effort | Minutes | Hours to weeks of design work |
| Control over layout | None — Rust generates it | Full — every monument and road placed by hand |
| Server config used | `seed`, `worldsize` | `levelurl` pointing to a hosted `.map` |
| File hosting needed | No | Yes — public direct-download URL |
| Best for | Fresh variety, quick wipes | Themed servers, roleplay, unique PvE |
How do you set up a custom procedural map?
The procedural route needs no external files. You edit two values in your server startup configuration (the command line or config file your Rust server reads on launch).
“`bash
+server.seed 1948572 +server.worldsize 4000 “`
The seed is any integer; the same seed plus the same world size always produces the same map, which is useful when you want a reproducible world. The world size is measured in meters and typically ranges from roughly 1000 to 6000. Larger sizes mean more terrain, more monuments, and noticeably higher RAM and CPU demand.
A few practical notes:
- Match seed and size together. A map is defined by *both* values. Keep them as a pair when you document or share your server’s world.
- Bigger is not always better. A 6000 world on an underpowered box leads to long generation times and laggy gameplay. Size to your hardware.
- Pick a seed you like, then lock it. Many admins generate several seeds, preview them on a test instance, and commit to the one that plays best.
This is genuinely a “custom” map in that no two seed/size combinations are alike, and it requires nothing beyond the two config lines above.
How do you make a hand-made custom map?
Hand-made maps are built in RustEdit, a widely used third-party map editor for Rust. Inside the editor you sculpt terrain, lay roads and rivers, place stock and custom monuments, drop prefabs, and define spawn points. When the design is finished, you export the world as a `.map` file — a single binary file that contains the entire handcrafted world.
The editing itself is a design discipline and outside the scope of a hosting guide. What matters for your server is the output: one `.map` file. Everything from here is about delivering that file to the server and its players.
Many hand-made maps also rely on Oxide/uMod, the plugin framework for Rust. Custom monuments, loot tables, NPC behavior, and special events frequently depend on plugins, and some RustEdit features expect the uMod extension to be present. If your map’s description mentions required plugins, install Oxide/uMod on the server before loading the map.
How do you load a custom .map file onto the server?
This is the step that surprises newcomers, and it is the core insight of this entire guide:
You do not upload the `.map` file directly to your Rust server. Instead, you host the file at a public, direct-download URL and point the server’s `server.levelurl` setting at that URL. On startup the server downloads the map from the URL and loads it. When players connect, *their* clients download the same map from that same URL so everyone is on the identical world.
That means two things must be true at once:
- The `.map` file sits at a reliable, publicly reachable direct-download link (the URL must serve the raw file, not an HTML download page).
- Your server config has the correct `levelurl` line.
“`bash
+server.levelurl “https://files.example.com/maps/yourmap.map” “`
When `levelurl` is set, Rust ignores procedural generation entirely and uses the downloaded map instead. You generally do not combine `levelurl` with `seed`/`worldsize` for the same world — `levelurl` takes over.
Why the file hosting matters as much as the config
Because both the server and every connecting player pull the `.map` from that URL, the hosting behind the link is part of your live infrastructure, not an afterthought:
- A `.map` file can be large. Slow or unreliable hosting means players hit long load screens or fail to connect.
- The link must serve a direct download — many generic file-share pages return an interstitial page instead of the raw file, which breaks the download.
- If the URL goes down, new players cannot join, even if the server itself is healthy.
This is exactly why admins running serious custom-map servers want predictable storage and bandwidth they control, rather than depending on a free file host that may rate-limit or expire links.
How do you test a custom map before going live?
Treat a custom map like a deployment. Validate it on a separate instance before pointing your main server at it.
- Stand up a test server with the same `levelurl` (or seed/size) and connect with your own client to confirm the map downloads and loads cleanly.
- Verify required plugins. If the map depends on Oxide/uMod plugins for monuments or events, confirm they load without console errors.
- Use the staging branch when appropriate. Rust offers a staging branch for testing upcoming changes; if a map or plugin targets staging behavior, test there before committing your live server.
- Check the download path from a clean client. Connect from a machine that has never loaded the map to confirm the client-side download works the way a real new player would experience it.
A short config and connectivity checklist before a wipe saves you from a launch where players cannot join because the map URL was misconfigured.
Running custom-map Rust servers on DarazHost
Loading a custom map well is as much about infrastructure as it is about config. DarazHost VPS and dedicated server plans give you the root access and headroom to run a Rust server the way custom maps demand.
With a DarazHost plan you can:
- Set your own server config — `server.seed`, `server.worldsize`, and `server.levelurl` — with full control of the startup command and config files.
- Host the `.map` file on infrastructure you control, with reliable network throughput and SSD storage so both the server and connecting players download the map quickly and consistently.
- Install and run Oxide/uMod and the plugins your custom monuments and events depend on, without platform restrictions.
- Scale CPU, RAM, and storage to handle larger world sizes and busier player counts.
- Lean on 24/7 support when you need a hand with deployment, networking, or configuration.
If you are moving from a casual procedural server to a polished hand-made map, having dedicated resources and a dependable place to host the `.map` file removes the two most common failure points in one step.
Frequently asked questions
Is a custom seed really a “custom” map? Yes, in the practical sense. A unique `server.seed` and `server.worldsize` combination produces a world no other server has unless they use the exact same pair. It is procedurally generated rather than hand-designed, but it is genuinely custom and the easiest option to set up.
Do I upload the .map file to my server? No. You host the `.map` file at a public direct-download URL and set `server.levelurl` to that URL. The server downloads the map on startup, and connecting players download it from the same link, so reliable file hosting is essential.
Do I need RustEdit to use a custom map? You need RustEdit to *create* a hand-made map. To simply *run* someone else’s `.map` file, you only need the hosted `.map` URL and the correct `levelurl` config — though many custom maps also require Oxide/uMod plugins to function fully.
Why won’t my custom map load? The most common causes are a `levelurl` that points to an HTML download page instead of the raw `.map` file, an unreachable or rate-limited host, or missing Oxide/uMod plugins the map depends on. Test the link in a browser to confirm it downloads the raw file directly.
Can I switch between a procedural and a hand-made map? Yes. Remove or clear `server.levelurl` to return to procedural generation with your `seed` and `worldsize`, or set `levelurl` to use a hand-made map. The server uses one or the other per world, not both at once.
