Wiki
Map MakingUpdated June 8, 2026

Making a BeamNG.drive Map From Scratch

Full walkthrough covering terrain generation, file setup, roads, meshes, foliage, tunnels, animations, and publishing.

Before you start

This guide covers building a custom BeamNG map from scratch. It goes through terrain generation, texture baking, file setup, roads, custom meshes, foliage, tunnels, animations, and packaging for upload. You can skip sections you already know.

If you want a real-world location instead of a fictional one, look into MapNG -- it can pull real elevation data for you.

Tools used in this guide:

  • Blender (with A.N.T Landscape addon)
  • Paint.NET
  • GIMP
  • BeamNG World Editor
  • Several World Editor addons (listed where relevant)

Back up your level folder every 1-2 weeks. A single power outage while the World Editor is open can corrupt items.level.json inside the main folder, which wipes everything you placed. This is not a maybe, it happens.

Blender basics

Blender gets used throughout this guide. Here is a quick rundown of the interface before we get into anything map-related.

The interface

(1) Toolbar -- changes depending on the active mode. In Object mode you get basic transform tools.

(2) Scene tree (Outliner) -- lists every object in the project. Organise with collections (folders). The eye icon hides objects, the camera icon excludes them from renders.

(3) Properties (Inspector) -- scene settings, object settings, materials, physics, etc.

(4) File and Edit menus -- save/export/import under File. Blender preferences under Edit.

(5) Workspaces -- tabs along the top that switch the UI layout. The main ones here are Layout, Shading, and UV Editing.

You can resize any panel by holding and dragging its edge. UI layout changes are per-project, not global.

Camera navigation

  • Middle mouse hold + drag -- rotate
  • Scroll wheel -- zoom
  • Shift + middle mouse hold -- pan
  • The RGB gizmo in the top right locks to orthographic views. Numpad does the same.

If you have no numpad, go to Edit > Preferences > Input and enable Emulate numpad. If you prefer not to use middle mouse, enable Emulate 3 button mouse and use Alt instead.

For GPU rendering (much faster baking): Edit > Preferences > System > Cycles render devices -- enable CUDA and select your GPU. You also need to switch the device to GPU Compute under the Render tab later.

Moving, scaling, rotating

Select the default cube to try these out.

  • G -- grab/move. Move mouse, left click to confirm, Esc to cancel.
  • S -- scale.
  • R -- rotate.
  • Ctrl+Z -- undo. Also undoes mode switches and selections, which is occasionally useful.

To lock movement to one axis, press the shortcut then the axis key. For example: G > Z moves only on Z. To lock to two axes at once, hold Shift and press the axis to exclude. S > Shift+Z scales on X and Y only.

Do not use Ctrl+C / Ctrl+V to duplicate -- that copies materials too and causes problems later. Use Shift+D to duplicate, then Esc to drop it in place.

New objects: Shift+A in Object mode.

Search for anything: F3 or Spacebar.

Object mode vs Edit mode

Changes made in Object mode (move, scale, rotate) affect the container, not the mesh itself. This can break modifiers. To apply those transforms to the actual mesh, go to Object > Apply > All Transforms. After applying, the numbers reset to default but the shape stays.

The orange origin dot is the rotation/scale pivot. Move it via Object > Set Origin. Keep origins near the world centre unless you have a specific reason not to. Extending objects slightly below the ground plane (the X/Y axis floor) reduces floating when placed in-game.

To enter Edit mode: press Tab with an object selected, or use the dropdown at the top left. Tab toggles between Edit mode and whatever mode you were in before.

In Edit mode you are working on the mesh directly. Meshes are made of vertices, edges, and faces.

  • Two vertices connected = edge
  • Three or more vertices connected = face

Keep faces as quads where possible. Triangles are fine. N-gons can cause issues on export (everything becomes triangles anyway).

Ctrl+Tab to cycle between modes.

Face orientation

Enable Viewport Overlays > Face Orientation. Blue = front face. Red = back face. Back faces are invisible in-game by default, so anything red will have see-through geometry. Fix flipped faces with Alt+N > Flip, or select everything and use Alt+N > Recalculate Outside.

Bevel

In edge select mode, select an edge and press Ctrl+B. Move the mouse to set the width, scroll to add segments. The settings panel that appears in the bottom left can be reopened with F9 if you accidentally close it.

Shade Smooth

In Object mode: Object > Shade Smooth. Newer Blender versions apply an angle limit automatically so 90-degree edges stay sharp. On older versions, set the angle manually under Data > Inspector > Normals.

Materials and vertex paint

Create a new material in the Inspector material tab. To actually see it, switch from Solid view to Material Preview (hold Z and select it, or click the third sphere icon in the top right).

In the Shading workspace, you will see the node setup. Add nodes with Shift+A. The key nodes here are Principled BSDF and Material Output.

To set up vertex paint preview: add a Color Attribute node (Shift+A > Input > Color Attribute) and connect its Color output to Base Color of the Principled BSDF. The material will look black until you enter Vertex Paint mode, which is correct.

Note: the Blender shading node setup does not transfer to BeamNG. Only material names and their face assignments carry over. Textures connected to Principled BSDF transfer if you enable that option on export.

To assign a material to specific faces: go to Edit mode, select the faces, pick the material in the material list, and click Assign.

Vertex paint workflow:

  1. In Edit mode, select the faces you want to paint
  2. Switch to Vertex Paint mode
  3. Enable Vertex Selection at the top -- this locks paint to the faces selected in Edit mode
  4. Press Ctrl+X or go to Paint > Set Vertex Colors

Colour can bleed between adjacent faces. To prevent this, separate the faces in Edit mode first with Y.

The material used on the lowest LOD mesh should be named lod_vertcol. It uses only vertex colour, which reduces drawcalls.

Quick tips:

  • Enable Statistics under Viewport Overlays to see poly count
  • Focus on a single object with Numpad / (or \ | if using numpad emulation). Press again to unfocus

Making terrain

You could build terrain inside BeamNG using the World Editor, but using dedicated tools outside is faster and gives you far more control. This guide uses Blender since it is free and unrestricted. Alternatives include Gaea 2.0, World Machine, and L3DT, though some of those have limited free versions.

Setting up A.N.T Landscape

On older Blender versions, A.N.T Landscape is already in the addon list -- go to Edit > Preferences > Add-ons and enable it. On newer versions you need to download it separately and drag the zip into Blender to install.

Generating the terrain shape

  1. Delete everything in the scene: A > Del
  2. Press N to open the side panel, go to the Create tab, open Landscape and click it
  3. A settings panel appears in the bottom left -- click to expand it
  4. Pick a preset that roughly matches what you are going for (Mountain 1 is a solid starting point)
  5. Adjust Noise Base, Falloff X/Y, Edge Level to taste. There is no single right answer here
  6. If you close the settings box accidentally, press F9 to get it back (or delete and regenerate -- it keeps your last settings)
  7. Keep mesh size at 2.0
  8. Once the shape looks right, set Subdivisions X and Y to 400-800 depending on your machine. 512x512 is a good middle ground

Erosion

Go to Landscape Tools > Landscape Eroder. Opening it causes a brief lag spike. Set the operator preset to Strong Erosion, Iterations to 12, and Kd to 0.05 for a rougher look. Changing any setting also causes lag -- be patient.

Terrain colours

Create a new material and name it Color. Switch to the Shading workspace.

If you have PBR textures (you can find free ones online), connect them to the Principled BSDF inputs. Normal textures go into the Height input of a Bump Node, not directly into Normal. If you are skipping PBR for now, a basic Color node is fine.

For texture coordinate setup:

  1. Add a Texture Coordinate node and connect its UV output to the Vector input of a Mapping node
  2. Connect the Mapping node's Vector output to all image texture nodes
  3. Set X, Y, Z scale in the Mapping node to 10

For UV projection: switch to UV Editing workspace, go to Edit mode, select everything with A, press U, and choose Cube Projection.

To blend rock and grass using slope:

  1. Duplicate the rock node group (drag-select all nodes except Material Output, then Shift+D)
  2. Connect your grass texture into the duplicate
  3. Add a Mix Shader and connect both Principled BSDF nodes into it
  4. Add a Geometry node, connect Normal into Separate XYZ, then Z into a Color Ramp, then Color Ramp output into the Mix Shader Factor
  5. Adjust the Color Ramp to control how much slope shows rock vs grass

For a height-based material (sand at low elevations):

  • Use Position from the Geometry node instead of Normal
  • Run it through Separate XYZ > Z > Color Ramp, then into the Mix Shader Factor
  • Keep the Color Ramp compressed tight to control the transition height precisely

For noise variation on grass and sand:

  • Add a Noise Texture node into a Color Ramp, feed that into a Mix Color node set to Value blending
  • For hue variation, add another Mix RGB node set to Hue blending

Baking heightmap and masks

Create four new materials: Heightmap, RockMask, SandMask, GrassMask.

Heightmap material setup:

  1. In Edit mode with the terrain selected, assign the Heightmap material
  2. In the Shading workspace, delete the Principled BSDF
  3. Add: Geometry > Position > Separate XYZ > Z > Color Ramp > Emission > Material Output
  4. Slide the white stopper on the Color Ramp left until the terrain peak is bright but the gradient still has detail

Mask materials:

  • Copy the Geometry/Separate/Color Ramp nodes from the Color material that blend rock and grass
  • Paste into RockMask, add a second Color Ramp after the first one, connect it to an Emission shader
  • Set the second Color Ramp interpolation to Constant, move white stopper left. White = rock present, black = no rock
  • Repeat for SandMask (you may need to swap the stoppers)
  • For GrassMask: combine the sand and rock Color Ramp outputs with a Mix Color node set to Lighten at 1.000, then invert with a Color Ramp with the stops flipped

Baking plane setup:

  1. Add a plane (Shift+A > Mesh > Plane). If terrain mesh size is 2.0 it will match exactly
  2. Move it slightly above the terrain: G > Z
  3. Create a new material called Baking
  4. In Shading workspace, add an Image Texture node, connect it to Base Color
  5. Click + New in the Image Texture node. Size options: 512, 1024, 2048, 4096, 8192. 1024x1024 is standard. Italy map is 4096.

Running the bake:

  1. Select the terrain object, assign the Color material in Edit mode
  2. Hold Shift and select the baking plane
  3. In the Render tab: set engine to Cycles, device to GPU Compute, Max Samples to 2048 (minimum 1024 for heightmap or it will be bumpy)
  4. Scroll to Bake, set Bake type to Diffuse
  5. Disable Direct and Indirect, keep only Color enabled
  6. Enable Selected to Active
  7. Click Bake

If it errors: make sure terrain is selected first, then the plane, image texture node is selected, Selected to Active is on, and a new image was created in the node.

To find the baked image, click the picture icon with a triangle in the left panel and scroll to it. Save via the 3-line menu > Image > Save As.

Export settings:

  • Color texture: PNG, RGB, 8-bit
  • If using PBR: also bake Normal, Ambient Occlusion, and Roughness using the same Diffuse bake type
  • Heightmap (use Emission bake type): BW, 16-bit, Linear color space, Compression 0. Any deviation here causes bumpy terrain in-game
  • Masks (Emission bake type): RGB, 8-bit, sRGB

Cleaning up masks in Paint.NET: The masks must be pure black and white -- no grey. Open each mask in Paint.NET, go to Adjustments > Levels, move the black handle all the way up, and save. Repeat for each mask.

File setup

Copying the template

  1. Go to the BeamNG install directory (Steam: right click > Manage > Browse Local Files)
  2. Navigate to content > levels > template.zip > levels > template
  3. Select everything with Ctrl+A, copy with Ctrl+C
  4. Open the BeamNG launcher > Manage User Folders > Open User Folder
  5. Open the current folder, create a levels folder inside it
  6. Inside levels, create a folder named after your map (example: TerrainTutorial)
  7. Paste the template files inside your map folder

Files you can delete: template.ter.depth.png, template.forest.json, map.json, main.forestbrushes.json, main.decals.json, and the import folder

Inside the art folder, delete: null_n.dds, the forest folder, and inside shapes delete trees. You can keep or delete the road folder depending on whether you want those textures.

Editing the config files

info.json -- change the Author field, delete the line "isAuxiliary": true,, and change the Title. Everything else can stay for now.

theTerrain.terrain.json -- find and replace every instance of the word template with the name of your map folder.

art folder -- inside each subfolder there is a main.material.json. Find and replace template with your map name in each one. Notepad++ makes this fast: Ctrl+H opens the replace tool. You can skip all of these except the terrains folder, which is required.

The map should now load correctly in-game.

World Editor overview

Press F11 on any map to open the World Editor.

  1. Outliner (Inspector) -- all objects in the level, organised in folders
  2. Window menu -- additional tools, Material Editor, Asset Browser
  3. Object Select -- select, move (1), rotate (2), scale (3) objects
  4. Mesh Road Editor -- place roads that sculpt into terrain
  5. Decal Road Editor -- visual-only road surfaces, also used for AI paths
  6. Terrain Tools -- heightmap import, terrain material painting, sculpting
  7. Inspector panel -- edit object properties: textures, collision types, etc.
  8. Forest Editor -- create brushes and paint objects onto the terrain

Roads -- Method B: Blender splines (do this before importing heightmap)

This method scales better for larger maps but requires more Blender knowledge. It uses splines in Blender combined with GIMP to bake roads into the heightmap before it is imported into BeamNG. Credit to LJFHutch for the original technique.

If you are importing an existing heightmap

If you did not generate terrain in Blender and instead have a heightmap from another source:

  1. Add a new Mesh > Grid, set subdivisions to 200-600 and size to 2
  2. Add a Displace modifier. Set strength to: (terrain height in meters) / (half of map size). Example for 2048 map at 150m height: 150 / 1024
  3. Click New in the modifier, set Coordinates to UV
  4. Go to the Texture tab, open the heightmap, set Color Space to Linear, under Mapping set Extension to Extend
  5. Press N, go to View, change End to a large value like 100000 to remove the viewport fog

Building the road shape

Keep the terrain at Blender scale (do not scale it up to real size -- it breaks the heightmap material and the road height calculation).

Hide the baking plane. Add a new plane for the road.

For an 8-meter wide road, scale to 14 meters to give the terrain transition room. Since the terrain is not at real scale, divide by half the terrain resolution: for a 2048 map that is 14 / 1024. You can type this division directly into the value box in Blender.

Focus on the road mesh with ** (under Backspace or left of Enter).

Add an Array modifier and a Curve modifier to the plane.

In Edit mode (Tab), scale the plane thin along X: S > X. Then:

  1. Use Edge Select, select left and right edges
  2. E > Esc > S > Y to push them outward slightly, then G > Z to lower them slightly
  3. Select the two inner edges, Ctrl+B and scroll to bevel them

This cross-section becomes the road profile. Scale it down on Z if you want it to hug the terrain more closely.

Unfocus with ** again.

Building the spline curve

Add a new plane, move it up above terrain (G > Z). In Edge Select mode, delete two edges on one side so you are left with a single line.

Add a Shrinkwrap modifier to this line and set the terrain as the Target. Add a Subdivision modifier and set Levels Viewport to 5-9 for a smooth result. You can add a second Subdivision at the top at 1-3 levels to improve terrain-following, but this also makes the line more wavy.

Trace the road path using E to extrude the line. If points are too far apart and floating, select two adjacent points and use the Edge tab > Subdivide to add a point between them.

For intersections: roads cannot branch on a single spline. Use Shift+D on a point, then P to separate it into a new line for the branch.

Once the path is correct:

  1. Press Ctrl+A on each modifier from top to bottom to apply them in order
  2. Select the line, go to Object > Convert > Curve
  3. In the Data tab (curve icon with two dots), change Twist Method to Z-Up to prevent road twisting at bends

Repeat for any branch lines.

Connecting road mesh to curve

Select the road plane, set the Curve Object under the Curve modifier to one of your curves. Adjust Count in the Array modifier until the road fills the whole curve. If the road starts too early or late, move it with G > X.

For road banking: in Edit mode on the curve, enable Proportional Editing (O), set falloff to Inverse Square, select a point, and press Ctrl+T to tilt. Scroll to adjust the proportional radius.

For matching intersection curves: change falloff to Smooth, then move and tilt the curve points until the roads line up well enough. Use Alt+S to scale curve width at intersections.

Baking roads into the heightmap

Set the road material to the Heightmap material. Do not apply the modifiers yet.

Unhide the baking plane. Shift-select all roads, then select the baking plane. Bake using the same process as before, but set Margin Size to 0.

Save as 16-bit RGBA PNG.

Compositing in GIMP

  1. Open the heightmap in GIMP
  2. Drag the road bake in as a layer. If it is misaligned, enable View > Snap to Canvas Edges and use the move tool with Shift held
  3. Adjust brightness under Colors > Brightness-Contrast if the road is too raised or too sunken
  4. Duplicate the road layer twice
  5. Bottom layer: Gaussian Blur, Size X and Y both at 10-20
  6. Middle layer: Gaussian Blur at 2-7
  7. Top layer: no blur (blur makes the road surface bumpy)
  8. Copy both blurred layers 5-10 times each and merge them to make the terrain transition visible
  9. Export as: 16 bpc GRAY, Compression 0

You can also add the unblurred road texture to the colour texture so the road is visible in-game.

Making spline masks

Back in Blender:

  1. In Edit mode on the road mesh, delete all faces except the centre one
  2. Assign a new Emission material (just an Emission shader connected to Surface -- no Principled BSDF)
  3. Select the curve, enter Edit mode, select all with A, scale to 0 on Z: S > Z > 0
  4. Press Alt+T to clear tilt
  5. In Data tab, untick Radius under Curve Deform

Bake each road individually (road mesh selected first, then baking plane, Emission bake type). Save as BW 16-bit PNG, Compression 0, Linear color space. The result should look like a white line on a black background.

Fixing the spline mask import bug (BeamNG 0.38)

Locate your BeamNG install folder, then navigate to: BeamNG.drive\lua\ge\extensions\editor\roadSpline

Open groupMgr.lua in Notepad. Find the line starting with M.convertPathsToRoadGroups = at the bottom of the file and replace the entire line with:

M.convertPathsToRoadSplines = convertPathsToRoadSplines

Thanks to Nikluz for finding this fix.

Importing spline masks in World Editor

  1. Open BeamNG > World Editor > find Master Spline in the top bar
  2. Click the disk icon with + to import a bitmap mask, locate your saved PNG
  3. Go to Generation tab, set Base Width to your road width (8 meters)
  4. Click the lightning/zap icon to auto-generate a road line
  5. Click the red hand icon to convert it
  6. Click the wavy icon with two arrows to push the spline above the terrain

The bitmask detection is not perfect -- move spline nodes manually to match the road. You can add new nodes by clicking on the spline.

Once positioned, go back to Layers and create a new road spline linked to it (first icon). If you plan to edit the nodes more, delete the road spline layer and redo it after editing -- it is very laggy to work with while active.

Once you exit the level, splines are applied permanently. To save mid-work, use the alexkidd71 save/load mastersplines plugin on the forums.

The spline tool can also paint terrain materials and be used for guardrails and barriers.

Importing heightmap and masks

BeamNG's terrain system is old (Torque3D-based). Follow these steps in exact order or things will break.

  1. Load your map in BeamNG (if it does not load, make sure you deleted the isAuxiliary line from info.json)
  2. Copy textures to the right places:
    • Heightmap and masks go directly into your map folder
    • Colour (and PBR normal/roughness/AO) go into art > Terrains
  3. Press J to pause, F11 for World Editor
  4. Open Terrain Tools > Terrain Painter, expand the menu, open Terrain Material Library
  5. Click + to create a new material, name it Rock, set ground model to rock, click Add Material
  6. Set the top texture to your terrain colour texture, set scaling to 1024 (or your map size), click Save Changes to File
  7. Do the same for the existing Grass and Rock materials
  8. Close both menus and press Ctrl+S -- save now

Follow these next steps exactly.

  1. Use Object Select to delete the terrain
  2. Go back to Terrain Tools. Make sure Terrain Painter is open -- the World Editor GUI will bug out. Press X on the Terrain Painter panel, but make sure Terrain Painter is still selected at the top. The GUI will return to normal
  3. Select the right-most icon: Import Terrain
  4. Leave max height alone for now. Click the three dots next to Height Map Image and select your heightmap. It should display in red and black if exported correctly
  5. Under Texture Maps, click + and add the three mask images in this order: Grass, Rock, Sand. Set each one's material to match
  6. Click Import. Point your camera up and away from the terrain before importing -- looking at it during import can crash the game
  7. If it crashes, reopen and retry. If it keeps crashing, try importing without masks first
  8. Select the terrain object and drag it up (it spawns below water level)
  9. Open the Inspector and set maxHeight to 300 (adjust based on your terrain)
  10. Press Ctrl+S -- save immediately

You may need to reopen the game to access Terrain Tools again without crashing.

If a grass texture is missing after import: click Add Terrain Material and add Grass. Then delete it. Then in Terrain Material Library, copy the settings from the Grass material into the Grass0 material. This is a quirk of the system and only happens on initial setup.

Fixing terrain issues:

  • Bumpy/blocky? Recheck heightmap export settings. Try a small Gaussian blur in GIMP if needed (Paint.NET cannot export 16-bit PNG)
  • Crashing on every import attempt? Try the BeamNG Tools for Map Creators by alexkidd71
  • Masks not working? Delete the Warning material, add Grass manually, then the terrain will show as all-grass. Add Rock and Sand materials and use Auto Paint with Slope Min set to 20-40 for rock, and Height Max set to 30-100 for sand

Setting the spawn point: Use Object Select with Translate (shortcut 1). In the Scene Tree under PlayerDropPoints, find the SpawnSphere and position it somewhere on the terrain.

Manual roads (World Editor method)

This method works well for smaller maps and is more straightforward than the spline tools.

Placing the mesh road

  1. Select Mesh Road Editor from the top bar
  2. Hold Alt and click to place road points across the terrain
  3. Keep point intervals consistent and dense enough for smooth curves
  4. With the road selected, set breakAngle to 1 in the Inspector for smooth corners
  5. Switch to Object Select, use Translate (1) to move the entire road slightly under the terrain
  6. For banking: in Mesh Road Editor, select a point and use Rotate (2) to tilt it
  7. Select all road points with Ctrl+A, set Node Depth to 8 and Node Width to 16-18 (or 10-12 for a single lane)

Sculpting the terrain to the road

There is a Terraform tool under Terrain Tools that is supposed to do this automatically, but it was broken as of 0.38. If it works, use it. If not:

  1. In Terrain Tools, use Align with mesh (UP) and paint along the entire road
  2. Then use Align with mesh (DOWN)
  3. Hide the mesh road in the Scene Tree (eye icon)
  4. Use Really Smooth (new) to smooth the terrain edges on both sides of the road. Use a smaller brush and do not cut into the actual road surface

Converting mesh road to decal road

Install BeamNG Drive World Editor Community Toolpack by stuffi3000 -- drop the lua folder directly into your current folder from the zip. New tools appear under Window.

  1. Unhide the mesh road
  2. Open Mesh Decal Road Convert from Window
  3. Select the mesh road, click Get from Selection, then Convert to Decalroad
  4. Hide the mesh road again
  5. In Decal Road Editor, select the new road, Ctrl+A to select all nodes, set node width to 7-9
  6. Set the material to road_patches1 and textureLength to 50

Painting asphalt material

  1. Go to Terrain Tools > Terrain Painter > Terrain Material Library
  2. Create a new material called Asphalt (no textures needed for now)
  3. Add it to the terrain painter
  4. In Window, open Road Material Painter, select the decal road with Get from Selection
  5. Set material to Asphalt, Margin to 1 or 1.5, click Paint Material Under Road

If sections are missing paint, do those manually. If the decal road stops rendering past a certain point, increase the detail value under ImprovedSpline in the Inspector from 0.1 to 0.2. For very long roads, split the decal road at the point where it stops.

Add your asphalt texture to the material -- a plain dark grey image works fine. If custom normals look blown out, try inverting the colours in Paint.NET.

Road lines

You can create lines in two ways:

Option A (individual decal roads):

  1. In Scene Tree, select the decal road, Ctrl+C > Ctrl+V to copy it
  2. In Decal Road Editor, select the copy, Ctrl+A, scale nodes to 0.2-0.3
  3. Change material to Empty

For edge lines, use Road-Edge Generator from Window, Get from Selection, set Road-Edge Width to 0.2 and Overlap/offset to 4, Material to Empty. Generate, then select Invert Edge Placement and generate again.

Option B (texture with double line):

  1. Create a texture image with two road lines on a transparent background
  2. Copy it into art > Textures
  3. In Material Editor (Window), create a new material called DoubleRoadLine
  4. Click the green Switch to v1.5 button
  5. Under Opacity Map, select your texture
  6. Under Advance - All Layers: enable Alpha Clip, set to around 17
  7. Under Additional Info: set Material Tag 0 to RoadAndPath so it appears in decal road material selection

Road edges and AI path

Road edge: Use Road-Edge Generator with material m_road_asphalt_edge, texture length 30-80, width 2.5, offset 0.2. If the edge faces the wrong direction, toggle Left/Right placement. Four edge texture variants are available -- search for "Edge" in the decal material selector.

AI path:

  1. Copy the doubleroadlines or asphalt patches decal road
  2. Change the material of the copy to road_invisible
  3. Set drivability to 1
  4. In Decal Road Editor, uncheck non-ai roads selectable to prevent selecting them accidentally
  5. At intersections, expand the node width to give AI more room

Exit World Editor. Press Ctrl+L to reload Lua. Roads now show on the minimap and AI traffic works.

If AI is not spawning on the roads, make sure gatedRoad is not checked in the Inspector.

For left-hand traffic, add this to info.json before the closing bracket:

"roadRules": {
  "rightHandDrive": true
}

Road intersections

Intersections require three individual decal road lines. If you want to take the shortcut, a single wide decal road texture cut before the intersection also works.

Keep the wide singular decal road in place until you are done. It makes it much easier to align the individual lines consistently.

Consistent spacing matters. As a road approaches a corner, start halving the spacing between decal road nodes gradually. Dense nodes in corners produce more circular curves. Too sparse and it will kink.

Workflow:

  1. Align all decal roads and road edges at the intersection
  2. Add individual lines that match the singular decal road where they meet
  3. Split and shorten the singular road so it transitions cleanly
  4. At the corners, split the road edge transition decal, move sections to each corner, select both with Ctrl, and use Fuse Roads in the Inspector
  5. Reshape the fused decal road points to get a circular corner shape
  6. Repaint the asphalt in the intersection area
  7. Cut the centre dashed line at the intersection and change its material to line_dashed_short

For a more complex intersection, add a large singular decal road at the new lane entry point and expand from there. The zebra diagonal material works well in the intersection box.

Circular roads (roundabouts, roundabout corners):

  1. Place a cylinder mesh as a reference -- scale it to the circle you need
  2. Trace the corners of the cylinder with the Decal Road Editor at a consistent node interval
  3. In the Inspector under Improved Spline, enable Looped Skipping every other corner works for smaller circles.

Importing meshes

Exporting from Blender

BeamNG uses the .dae (Collada) format. On Blender 5.0 and newer, native .dae support was removed. Install the Blender Collada CDAE (&DAE) Plugin by Grille: Edit > Preferences > Add-ons > click the arrow top right > Install from Disk.

LOD hierarchy setup:

  1. Press Shift+S > Cursor to World Origin
  2. Add an empty: Shift+A > Empty > Plain Axes
  3. Copy it three times (Ctrl+C > Ctrl+V three times)
  4. Hold Shift and drag three of them into the first one to nest them
  5. Rename the parent: Base00
  6. Rename the children:
    • bb_autobillboard25 (auto-generates a billboard at distance)
    • nulldetail10 (object disappears past this distance)
    • start01 (contains your actual mesh objects)
  7. Hold Shift and drag your mesh objects into start01

Naming your LOD meshes: End each mesh name with _aXXX where XXX is a pixel threshold number. The game switches LODs when the object takes up fewer screen pixels than the number. Example chain: _a550 > _a350 > _a120 > billboard (25px) > disappear (10px)

Each LOD should roughly halve the polygon count of the previous one. The lowest LOD should use the lod_vertcol material.

Exporting:

  1. Shift-select all meshes and empties up to Base00
  2. File > Export > BeamNG (.dae) or Collada (.dae)
  3. Enable Selection Only
  4. Export into a Meshes folder inside your level's art directory

Importing in BeamNG

Speed up Asset Browser scanning: Edit > Editor Preferences > Asset Browser, delete all directories except %level_name%. Then press Ctrl+L to reload Lua.

  1. Window > Asset Browser
  2. Navigate to your level > art > Meshes
  3. Hold-click the .dae and drag it onto the map
  4. If textures are missing, open Material Editor (Window menu)
  5. Use the syringe/picker icon and click your mesh to show only its materials
  6. Set textures for each material
  7. If using vertex paint: enable Vertex Color in the material

For collision: select the mesh with Object Select, open Inspector, set collisionType to Visible Mesh Final. For complex or repeated objects, build dedicated collision meshes to save RAM -- Visible Mesh Final on a lot of objects adds up.

For thin objects (poles, tree trunks): do not use Visible Mesh Final. Thin collision geometry grabs vehicles. Build a custom collision mesh instead (covered in the foliage section).

Importing foliage

For wind interaction on trees and bushes, vertex paint is required.

Vertex paint for wind:

  1. In Edit mode, select the faces you want to paint (or select by material)
  2. Enter Vertex Paint mode, enable Vertex Selection
  3. Paint using different colours per section:
    • Black -- no wind (trunk)
    • Red -- bends up and down
    • Blue -- flutter
    • Green -- per-instance bending
    • Purple -- a combination used often by BeamNG developers
  4. After painting, select everything and go to Paint > Smooth Vertex Colors

Custom collision mesh for foliage:

  1. Add a cube (Shift+A > Mesh > Cube), drag it into start01, name it colmesh-1
  2. The collision mesh cannot be thinner than 0.3 meters. Enable Edge Length in Overlays to check
  3. Reshape to match the trunk
  4. colmesh-1 does not need a material
  5. For leaves sound on collision, add a second cube inside colmesh-1 shaped around the leaf area, name its material leaves_col

Exporting: include the mesh objects, colmesh-1, and the empties in your export selection.

Importing:

  1. Import through Asset Browser first
  2. If no materials exist, use Material Editor: click New Material, use Pick from TTStatic to click the mesh and assign materials one by one
  3. After adding materials, reimport the model or reopen BeamNG for them to show on the mesh (this also breaks billboard -- clear cache after, see below)
  4. Under Advance - All Layers: enable Alpha Clip and Double Sided for tree/leaf materials
  5. For leaves_col: scroll to Additional Info, set Ground Type to LEAVES_THIN

Adding to Forest Tools:

  1. Delete the mesh from the level
  2. Open Forest Tools, go to Meshes tab, click the tree icon to add a new mesh
  3. Navigate to your level > art > Meshes, select the file
  4. Set radius (0.4 for a standard tree, smaller for bushes)
  5. Wind settings that work well: 12, 10, 4, 0.1, 0.6, 0.02, 0.04, 0.3, 0.4
  6. Go to Brushes, create a new group, create a new brush inside it, set ForestItemData to your tree
  7. Adjust ScaleMin/ScaleMax and SinkMin/SinkMax (sink prevents floating)
  8. Keep density low (2) to avoid mass-spawning

Manually clearing billboard cache

When a model is imported without materials and you assign them manually, BeamNG has already generated a billboard from the no-texture state. Clearing all cache is slow and moves your level files around.

Faster method:

  1. Exit BeamNG
  2. Navigate to the current folder
  3. Go to temp > levels > YourLevel > Art
  4. Delete the Meshes folder
  5. Reopen BeamNG -- cache regenerates cleanly

This does not affect your models or textures. The temp folder only holds cache and auto-generated billboards.

Custom tunnels

Laying out the tunnel in World Editor

  1. Enter World Editor (F11), open Mesh Road Editor
  2. Hold Alt and click to place two nodes spanning the tunnel length
  3. For very long tunnels where the endpoint is out of reach: place two short sections on one side, move the second node to the other side, then delete the extra node
  4. Position nodes at the cliff edges where the tunnel mouths will be
  5. Ctrl+A to select all nodes, set Node Width to 8-14 depending on tunnel width
  6. Export the mesh road: Object Select > select the road > File > Export Selected as Collada. It saves to the current folder by default

Leave the mesh road in place as a positioning reference.

Editing in Blender

On Blender 5.0 and above, check that your .dae import plugin supports importing (not just exporting). Some do not. Use an older Blender version if needed.

  1. Import the .dae mesh road
  2. Select the mesh, go to Data > Geometry Data > Clear Custom Split Normals Data
  3. In Edit mode, select all, go to Face > Tris to Quads (Alt+J) to clean up the mesh
  4. Select and delete the bottom face (X > Vertices with the bottom face selected)
  5. Select the top face, press E to extrude, input 6-10 for tunnel height in meters
  6. Select and delete the front and back faces (X > Only Faces)
  7. Enable Face Orientation in Overlays -- if the inside is red, select all and go to Alt+N > Flip
  8. Add a loop cut (Ctrl+R) near the bottom edge, slide it tight with G+G, then move the bottom edge slightly down for a smoother road transition
  9. Loop-select the outer edges at both ends (Alt+click), E > Esc > S to extrude and scale outward to make the tunnel mouth
  10. Loop-select those outer faces, Alt+E > Extrude Faces Along Normals to thicken the walls
  11. Select the back faces of the extrude, switch to Vertex Select, deselect the outer vertices, delete the inner ones (X)
  12. Refill the front face manually: Edge Select, select one outer and one inner edge, F to fill. Repeat 3 times. Do the same on the other end
  13. Fix any red faces with Alt+N > Flip
  14. Loop-select the upper inner edges, Ctrl+B to bevel with scroll for segments
  15. Object mode: Object > Shade Smooth. Older Blender: set auto smooth angle to 30-45 in Data > Normals

For texturing: add the lod_vertcol material, select the floor faces in Edit mode, separate with Y, vertex paint darker to roughly match asphalt.

Make LODs if needed, then export.

Importing the tunnel

  1. Import through Asset Browser
  2. Position it to match the mesh road you exported earlier
  3. Delete the mesh road
  4. Set collision type to Visible Final Mesh if you have not made a colmesh
  5. Sculpt terrain around the tunnel mouth:
    • Use Lower Height (pressure 2-10) to push terrain below and steepen the edges
    • Use Raise Height to blend the road approach
    • Mesh roads (hidden) help get a flat, accurate transition
  6. Use Clear Terrain in Terrain Tools with a small brush and pressure 100 to remove terrain inside the tunnel. Be careful not to click outside the terrain -- that creates holes
  7. If you cannot see the change, use Paint Material nearby to reveal it
  8. Use Restore Terrain if you cut too deep

Zones and portals (audio and lighting)

  1. In Create Object, add a Sound Space (box with speaker icon) in the middle of the tunnel
  2. Add a Zone and a Zone Portal (Create Object > Level)
  3. Scale and rotate the Zone and Sound Space to fill the tunnel interior, leaving a gap from the entrance
  4. Select the SFXSpace, change soundAmbience in Inspector to Level_Tunnel_Closed_Dynamic or Open_Dynamic
  5. Select the Zone, enable useAmbientLightColor, adjust the ambient light colour darker until it looks right inside
  6. Select the Zone Portal, scale to match the tunnel opening (X and Z axes), rotate to face the entrance, then move it inward until it turns green

Zones serve as occlusion volumes -- they hide terrain and vehicles outside them. The portal manages the transition so objects do not pop as vehicles enter.

Sidewalk spline

Four ways to make sidewalks:

  1. Decal road -- easiest, but visually flat against terrain and no collision
  2. Mesh road -- has geometry, but increases draw calls significantly
  3. Mesh road exported as static mesh -- requires UV work in Blender 4.5 or earlier only
  4. Sidewalk spline -- the method covered here. As of BeamNG 0.38.5 this is still WIP with no official documentation. It may change or be removed. Thanks to BrokenBrainCells for figuring out the custom asset requirements.

Making the sidewalk assets

You need two meshes: a square (straight sections) and a triangle (corners).

Square:

  1. Add a cube (Shift+A > Mesh > Cube), open the Add Cube panel, set size to 2
  2. In Edit mode, press S > Y and enter 1.26 to scale to 2.52 meters length
  3. Select and delete the bottom face (X > Only Face)
  4. Select the top face and move it down 0.6-0.9 meters (G > Z)
  5. Add a concrete material, UV unwrap with Smart UV Project (Edit mode, A, U > Smart UV Project)
  6. Rename the mesh to SidewalkTut_a100 in the Scene Tree
  7. Place it in the export hierarchy under start01
  8. Export as square.dae into a new folder inside art called sidewalkTut

The mesh name inside Blender does not matter. The filename must be square.dae exactly.

Triangle:

  1. Shift+D the square, Esc, rename it and remove the .001 suffix
  2. In Edit mode, select all, scale: S > Y > 0.992 to get exactly 2.5m length
  3. Vertex Select: select the 2 top vertices on the negative Y side, press M > At Center. Repeat for the 2 bottom vertices
  4. Edge Select: select a bottom edge, press F to fill it (triangle needs a bottom face for flipping)
  5. Reset the 3D cursor: Mesh > Snap > Cursor to World Origin (in edit mode)
  6. Select the bottom face, set pivot point to 3D Cursor (top bar)
  7. Scale the bottom face to 0 on Z: S > Z > 0
  8. Enable Edge Length. With the bottom face selected, press G > Z, read the height shown (example: 0.104), type that number then press minus to move it in the opposite direction. The triangle now mirrors equally above and below origin
  9. Re-UV (Smart UV Project)
  10. Export as triangle.dae next to square.dae

Using the sidewalk spline

  1. Locate the sidewalk spline tool in World Editor
  2. Click Add a new sidewalk spline
  3. Click the folder icon Select the Sidewalk Kit folder
  4. Navigate to your level > art > sidewalkTut, click Open
  5. The tool now shows the two .dae assets
  6. Click on the map to start placing. The sidewalk starts a short distance from where you click -- this is normal

For variants: add _varN.dae suffix to additional mesh files (N being the variant number).

Simple animated objects

Simple rotation/movement animations use Object Transform Keyframes. Complex animations that deform geometry need bones. Animated objects do not have animated collision -- collision uses only the first frame.

Spinning object (windmill)

  1. In Edit mode, select one face of the blades, Ctrl+L to select all linked faces, P > Selection to separate them
  2. Enter Edit mode on the blade mesh, select the blade centre or all blades
  3. Go to Mesh > Snap > Cursor to Selected
  4. Exit Edit mode, go to Object > Set Origin > Origin to 3D Cursor
  5. Set timeline End to 400 (or adjust for rotation speed)
  6. Set cursor to frame 1, press I > Rotation to create a rotation keyframe
  7. Go to frame 200, rotate 180 degrees along the rotation axis: R > Y > 180 (adjust axis as needed), press I > Rotation
  8. Go to frame 400, repeat the rotation keyframe
  9. Select all keyframes (A in timeline), right-click > Interpolation Mode > Linear to remove ease-in/out
  10. In the Animation tab, enable Manual Frame Range and Cyclic Animation

Make sure the timeline Start/End matches your animation range before exporting.

Object following a path (train, plane)

  1. Add a Bezier Curve, shape it in Edit mode using E to extrude points
  2. In the curve Data tab, set Twist Method to Z-up to prevent tilting on corners
  3. Under Path Animation: set the frame count (higher = slower). Match the timeline End to this value
  4. Select the object that follows the path. Make sure its origin is at world centre
  5. In the Constraints tab (chain icon), add Follow Path, set the curve as Target, enable Follow Curve, set Up Axis to Z and Forward Axis to match the object's front
  6. Click Animate Path and play to test. If direction is wrong, change Forward Axis (try -Y)
  7. When done: Object > Animation > Bake Action (check everything)
  8. The constraint disappears and keyframes appear in the timeline
  9. Adjust keyframes as needed -- scale by -1 to reverse direction, spread them to create slowdown
  10. Export normally. On newer Blender with dae plugin, enable Animation and set the end frame

For very long path animations where the object travels far from the origin: include a large bounding object in the export that covers the entire path area. Without this, the animated object becomes invisible past a distance threshold.

Animated flag

A proper cloth animation requires bones. The more bones and loop cuts, the better the result.

Setup:

  1. Add a plane, scale to flag proportions, rotate 90 degrees on Y
  2. In Edit mode, add vertical loop cuts (uneven number, recommend 7+) and horizontal loop cuts (recommend 2+)
  3. Add an Armature (Shift+A > Armature > Single Bone)
  4. In Edit mode of the bone, rotate -90 on X
  5. Hold Z to go Wireframe so you can see the flag topology
  6. Move the bone to the bottom-left corner, move the tip along Y to span 2 vertical columns
  7. Press E and keep extending along Y until you reach the flag edge
  8. Select all bones (A), Shift+D > Esc, then G > Z to move the row up to the next horizontal line. Repeat until all rows are covered
  9. Switch to Pose mode, rename each bone simply: b1, b2, b3 (bottom row), m1, m2, m3 (middle), t1, t2, t3 (top)

Vertex groups:

  1. Go to Object mode, select the flag, Edit mode, Data tab (triangle icon)
  2. Under Vertex Group, add a new group named Pins
  3. Switch to Vertex Select mode, select the left column of vertices (the fixed edge), click Assign
  4. Create one vertex group per bone, named to match each bone
  5. Select all vertices (A), go to Weight Paint
  6. Enable Vertex Selection, set Weight to 1
  7. Select each vertex group in order and paint the vertices corresponding to that bone

Bone constraints:

  1. Select the armature, go to Pose mode
  2. Go to Bone Constraints tab (chain icon)
  3. For each bone: add IK constraint (I shortcut), set the flag plane as Target, Chain Length to 1, Vertex Group to match the bone name Repeat for every bone.

Cloth simulation:

  1. Select the flag plane, go to Physics tab (circle icon)
  2. Enable Cloth, in the Cloth dropdown click the three-line icon > Cotton
  3. Under Collisions, enable Self Collisions
  4. Under Shape, set Pin Group to the Pins vertex group
  5. Add a Wind force field: Shift+A > Force Field > Wind
  6. Rotate -120 degrees on X so it faces slightly down onto the flag
  7. Move it above and behind the flag
  8. Set strength to 300-1000, noise to 0.2-1

If the flag hangs limp, scale both the armature and the flag up 2-3x, then Ctrl+A > Scale to apply. Adjust Vertex Mass in cloth settings (1-10).

Wind takes a second to kick in. Set timeline End to 300-600 so you have enough cloth simulation to work with. Match this in the cloth Cache settings or the simulation cuts off abruptly.

Baking the animation:

  1. Go to frame 0 (flag is flat)
  2. Select the flag, hold Shift, select the armature
  3. Ctrl+P > Armature Deform > With Automatic Weights
  4. Go to Modifiers, delete the Armature modifier that appeared
  5. Check weight paint -- automatic weights may not be correct. Fix any bones that have wrong vertex assignments (Weight = 1 to add, Weight = 0 to remove)
  6. Select the armature, Pose mode, select all (A)
  7. Go to Pose > Animation > Bake Action. Enable Only Selected Bones, Visual Keying, and Clear Constraints
  8. Back in Object mode, select the flag, add an Armature modifier, set Object to your armature

Looping:

  1. Find a frame near the end that matches a frame near the beginning
  2. Delete all keyframes before the matching start frame
  3. Select all, G to shift to frame 0
  4. Copy the new first frame (Ctrl+C), paste it 5-15 frames after the last frame
  5. Set timeline End to the last frame
  6. Select the two final frames, right-click > Interpolation Mode > Linear
  7. Play and verify the loop is smooth. Adjust the last frame position as needed

Exporting:

  1. Expand the armature in the Scene Tree to see the plane
  2. Rename the plane (e.g. flag_a80) and the armature (e.g. FlagArmature)
  3. Hold Shift and drag the armature, then the flag, into the export hierarchy inside start01
  4. If the flag escapes the armature, hold Shift and drag it back
  5. In Edit mode on the flag: select all, Shift+D > Esc, then G > X to offset slightly, then Alt+N > Flip to make the copy face the other way. This renders both sides without Double Sided material (which causes lighting issues)
  6. Enable Face Orientation -- both sides should be blue
  7. Select the flag, Object > Shade Smooth
  8. Export as Collada with Include Animations enabled

Billboard models and sequence animations

Camera-facing billboard model

For models that always face the camera (groundcover, small plants), use this LOD hierarchy:

base00
  nulldetail5
  start01
    bb_modelname_d10
    modelname_d50

Both mesh objects are identical -- one has the bb_ prefix and a lower _d threshold. The model must face the positive Y direction in Blender. The standard torque3D billboard method does not work in BeamNG. This hierarchy is the correct approach. Credit to alexkidd71 for discovering this.

If you have issues, try exporting without bb_autobillboard5.

Sequence texture animation

Only works with old-style materials (not v1.5).

  1. Prepare a sprite sheet: height = texture size, width = height x frame count. Example: 256px texture, 40 frames = 10240px wide. BeamNG does not accept images wider than that
  2. In GIMP: new document at those dimensions, enable View > Show Grid and Snap to Grid, configure grid spacing to match the texture height. Line up frames on the grid
  3. In Blender, UV unwrap the model:
    • Navigate gizmo, click Y axis
    • Edit mode, U > Project from View (Bounds)
  4. In UV Editing: enable snapping, enable Fixed Grid, set Fixed Subdivisions to frame count
  5. Move the right vertices (G > X) to align with the first frame
  6. Import into BeamNG and create a material in the old format (Version 1, not 1.5)
  7. Scroll to Animation Properties, enable Image Sequence
  8. Set Frames to (1 / total frame count). For 40 frames: 0.025. Ctrl+click the value to type it directly
  9. Frames/sec controls playback speed

Multiple spawn points

  1. Find the original spawn sphere in Scene Tree under PlayerDropPoints, name it Spawn1 in the Inspector
  2. Duplicate it and place copies around the map (Object Select + Shift+drag)
  3. Name them Spawn2, Spawn3, etc.
  4. Open info.json and add this before the closing bracket:
"defaultSpawnPointName": "Spawn1",
"spawnPoints": [
  {
    "translationId": "Main Spawn",
    "objectname": "Spawn1",
    "preview": "template_preview.png"
  },
  {
    "translationId": "Second Spawn",
    "objectname": "Spawn2",
    "preview": ""
  },
  {
    "translationId": "Third Spawn",
    "objectname": "Spawn3",
    "preview": ""
  }
]

Press Ctrl+L to reload Lua, then open the map with M and the spawn points appear.

Working gas station

  1. In World Editor, click the + (Create Object) icon at the top
  2. Under the BeamNG icon, find Gameplay Area and Point of Interest
  3. Place a Gameplay Area at the station (this is the trigger zone that opens the fuel GUI)
  4. Place a Point of Interest at the station (this is the map icon)
  5. Name them: gasstation_area_1 and gasstation_icon_1. Add _2, _3 etc. for additional stations
  6. In your map folder, create a folder called facilities
  7. Inside it, create a file called facilities.facilities.json
  8. Paste and edit this:
{
  "gasStations": [
    {
      "id": "gasstation_first",
      "name": "Gas Station",
      "description": "Gas Station",
      "preview": "",
      "energyTypes": ["gasoline", "diesel", "unknown", "n2o"],
      "pumps": [
        ["gasstation_Area_1", "gasstation_Icon_1"],
        ["gasstation_Area_2", "gasstation_Icon_1"]
      ]
    }
  ]
}

Remove the second pump entry if you only have one. Add more if needed. For electric vehicles, add "electricEnergy" to the energyTypes array. Preview images go directly in the facilities folder.

Press Ctrl+L to reload -- the station now works and shows on the map.

Packaging and uploading

  1. Add preview images to all spawn points and gas stations
  2. The zip must have this folder structure: levels > your_map_folder > all files. If your current levels folder has other content, create a second levels folder inside it, move your map folder in, then zip
  3. When the zip is opened, the first folder should be levels, then your map name, then files like info.json and art
  4. Do not rename the zip after uploading if you plan to release updates -- it can cause issues for existing installs
  5. Move the zip somewhere outside of your levels folder
  6. Make a backup before this next step
  7. Use BeamNG Tools for Map Creators by alexkidd71 -- select Map Shrinker, find your zip, select Delete, click Build Zipfile
  8. Click Working Directory to find the new zip, rename it to remove the _deploy_XXXXXX suffix
  9. Copy the zip into current > mods and test in-game -- check for missing textures and missing models before uploading