Vehicle Mod Basics

A modder finishes a truck model in Blender, exports it, builds the Unity prefab, packages a master bundle, and loads the vehicle into Unturned™ — only to find that the vehicle does not move, the driver sits inside the dashboard, the paint mask does nothing, or the suspension oscillates uncontrollably. Every one of these failure modes is the consequence of a specific configuration step that was skipped or set incorrectly. None of them indicate that the vehicle mod cannot be built; all of them are documented and resolvable.

This article documents the cohort-validated workflow that 57 Studios™ uses to build custom Unturned™ vehicle mods. The workflow covers prefab structure, WheelCollider configuration, seat transform placement, paintable material setup, and the .dat configuration fields that control runtime handling. The article assumes the reader has Unity 2022.3 installed, a working FBX import pipeline, and a vehicle mesh that has been modeled and textured. If any of those prerequisites are missing, the linked articles below are the starting point.

Prerequisites

• Unity 2022.3 LTS installed via Unity Hub. See How to Install Unity Editor.
• A vehicle mesh modeled, UV-mapped, and textured in Blender. The mesh should be a single FBX containing the body, the four wheels as separate sub-meshes, and any other animated parts (doors, hood, trunk) as separate sub-meshes.
• The FBX export workflow documented in How to Export an FBX.
• A .dat editing workflow. See How to Install Notepad++ for the recommended editor.
• A local Unturned™ install with single-player available for testing.

What you'll learn

• How to structure a vehicle prefab so that Unturned's InteractableVehicle script can find every required component.
• How to add and tune WheelCollider components for the four wheels.
• How to place seat transforms so that the driver and passengers sit in the correct positions.
• How to set up a paintable material that responds to in-game paint sprays.
• How to author the .dat file fields that control speed, steering, braking, fuel consumption, and engine sound.
• How to test the vehicle in single-player before bundling for distribution.
• How to diagnose the most common vehicle bugs (won't move, wrong seat position, paint not applying, suspension oscillating).

Background: how Unturned's vehicle system works

The Unturned™ vehicle runtime is built on Unity's physics system. Each vehicle is a single GameObject with a Rigidbody and an InteractableVehicle script. The script reads configuration from the .dat file at load time and applies the values to Unity's physics components. The wheels are WheelCollider components parented to the root GameObject; the wheel meshes are separate child GameObjects whose transforms are driven by the WheelCollider poses at runtime.

The cohort's mental model is that the vehicle prefab is a Unity scene-graph structure that satisfies Unturned's expectations, and the .dat file is a parameter set that Unturned applies to the prefab at runtime. The two halves are independent: a correctly-structured prefab with an incorrect .dat will produce incorrect handling but the vehicle will still load; a correctly-configured .dat against an incorrect prefab will fail to load or will produce a non-functional vehicle.

The sequence diagram above is the cohort's reference mental model. Every troubleshooting step in this article maps back to one of the arrows: a vehicle that won't load is failing at the "Instantiate prefab" step; a vehicle that loads but doesn't move is failing at the "Player input drives WheelColliders" step; a vehicle whose wheels float above the ground is failing at the "WheelCollider poses drive wheel meshes" step.

Vehicle prefab structure

The cohort-validated vehicle prefab hierarchy is documented below. The structure is the minimum that Unturned's InteractableVehicle script expects to find at load time. Additional child objects can be added freely, but the named child objects must be present and must follow the naming convention.

MyVehiclePrefab (root)
├── Body (MeshRenderer + MeshFilter for vehicle body)
├── Wheel_FrontLeft (empty GameObject with WheelCollider)
│   └── WheelMesh_FrontLeft (MeshRenderer + MeshFilter)
├── Wheel_FrontRight (empty GameObject with WheelCollider)
│   └── WheelMesh_FrontRight (MeshRenderer + MeshFilter)
├── Wheel_RearLeft (empty GameObject with WheelCollider)
│   └── WheelMesh_RearLeft (MeshRenderer + MeshFilter)
├── Wheel_RearRight (empty GameObject with WheelCollider)
│   └── WheelMesh_RearRight (MeshRenderer + MeshFilter)
├── Seats (empty GameObject, parent for seat transforms)
│   ├── Seat_Driver (empty GameObject with Seat marker tag)
│   ├── Seat_Passenger_0 (empty GameObject)
│   ├── Seat_Passenger_1 (empty GameObject)
│   └── Seat_Passenger_2 (empty GameObject)
├── Exits (empty GameObject, parent for exit transforms)
│   ├── Exit_Driver (empty GameObject)
│   ├── Exit_Passenger_0 (empty GameObject)
│   ├── Exit_Passenger_1 (empty GameObject)
│   └── Exit_Passenger_2 (empty GameObject)
├── Lights (empty GameObject, parent for light GameObjects)
│   ├── Light_HeadlightLeft (Light component)
│   ├── Light_HeadlightRight (Light component)
│   ├── Light_TaillightLeft (Light component)
│   └── Light_TaillightRight (Light component)
└── Effects (empty GameObject, parent for particle systems)
    ├── Exhaust (ParticleSystem)
    ├── Smoke_Damaged (ParticleSystem, played when damaged)
    └── Fire_Destroyed (ParticleSystem, played on destruction)

The naming convention is the cohort's recommendation. The names that begin with Wheel_, Seat_, Exit_, Light_, and Effect_ are matched by the cohort's vehicle authoring scripts; modders who use the convention can run the cohort's wiring scripts to automate the assignment of references. Modders who prefer to wire references manually can use any names.

Common mistake

Parenting the wheel meshes directly to the root instead of to the empty GameObject that holds the WheelCollider. The wheel mesh must be a child of the WheelCollider GameObject so that the mesh transform is driven by the WheelCollider pose at runtime. If the wheel mesh is parented directly to the root, the mesh will not follow the suspension travel.

Required components on the root GameObject

The root GameObject of the vehicle prefab must have a specific set of components. The cohort-validated component list is documented below.

Component	Purpose	Configuration
Rigidbody	Physics body for the vehicle.	Mass: typically 1500–3000 kg. Drag: 0.1. Angular Drag: 0.5. Use Gravity: Enabled. Is Kinematic: Disabled. Collision Detection: Continuous.
BoxCollider or MeshCollider	The chassis collider. Drives the vehicle's collision with the world.	Convex: Enabled if MeshCollider. Trigger: Disabled.
InteractableVehicle	The Unturned-specific vehicle script. Manages player interaction, seating, fuel, engine state.	Configured at runtime from the .dat file.
AudioSource	The engine audio source.	Spatial Blend: 1.0 (fully 3D). Loop: Enabled. Play On Awake: Disabled.

Did you know?

Unturned's InteractableVehicle script is the runtime component that ties the prefab to the .dat file. The script's properties are populated from the .dat at load time; the prefab itself does not store the handling parameters. The prefab is a template; the .dat is the configuration applied to instances of the template.

WheelCollider configuration

The WheelCollider is Unity's built-in physics component for a wheel. Each of the four wheels in the vehicle prefab is an empty GameObject with a WheelCollider component and a child GameObject that holds the wheel mesh.

The cohort-validated WheelCollider configuration for an Unturned™ ground vehicle is documented below. The values listed are starting points; specific vehicles (sports cars, off-road vehicles, military trucks) will deviate from the defaults in deliberate ways.

Wheel geometry

Setting	Cohort-validated value	Notes
Mass	20 kg	Per-wheel mass. Heavier wheels increase rotational inertia.
Radius	0.4 m	Should match the wheel mesh's radius. Mismatch produces wheels that float or sink into the ground.
Wheel Damping Rate	0.25	Damping of the wheel's rotation. Higher values make the wheel resist acceleration.
Suspension Distance	0.3 m	The maximum suspension travel. Most cars use 0.2–0.4. Off-road vehicles use 0.4–0.6.
Force App Point Distance	0.0 m	The distance below the wheel center where suspension forces are applied. 0.0 places forces at the wheel center.
Center	(0, 0, 0)	The local position of the wheel collider relative to its GameObject. Adjust only if the GameObject is not at the wheel center.

Suspension spring

Setting	Cohort-validated value	Notes
Spring	35000 N/m	The suspension stiffness. Heavier vehicles need higher values.
Damper	4500 N·s/m	The suspension damping. Roughly 10–20% of the spring value.
Target Position	0.5	The neutral suspension position. 0.5 places the wheel at the middle of its travel range.

Critical setting

The suspension spring and damper values are interdependent. A high spring with a low damper produces a bouncy vehicle that oscillates after every bump. A low spring with a high damper produces a vehicle that compresses on every bump and never returns to neutral. The cohort-validated 10:1 ratio (spring 35000, damper 4500) produces a balanced response for most vehicles.

Forward friction

Setting	Cohort-validated value	Notes
Extremum Slip	0.4	The wheel slip at peak forward grip.
Extremum Value	1.0	The peak forward friction coefficient.
Asymptote Slip	0.8	The wheel slip at the asymptotic forward grip.
Asymptote Value	0.5	The asymptotic forward friction coefficient.
Stiffness	1.0	A scalar multiplier applied to the entire forward friction curve.

Sideways friction

Setting	Cohort-validated value	Notes
Extremum Slip	0.2	The wheel slip at peak sideways grip.
Extremum Value	1.0	The peak sideways friction coefficient.
Asymptote Slip	0.5	The wheel slip at the asymptotic sideways grip.
Asymptote Value	0.75	The asymptotic sideways friction coefficient.
Stiffness	1.0	A scalar multiplier applied to the entire sideways friction curve.

The Sideways friction Stiffness value is the cohort's preferred tuning knob for vehicle handling. Lower values (0.5–0.7) produce a vehicle that drifts and slides; higher values (1.0–1.5) produce a vehicle that grips tightly and resists slides. Most vehicles ship at 1.0.

The diagnostic flowchart above is the cohort's recommended troubleshooting flow for a vehicle that does not move. Approximately 85 percent of "won't move" reports trace to one of the first four branches.

Seat transforms

Seat transforms are empty GameObjects that mark where each player sits when occupying the vehicle. The position, rotation, and parent of the seat transform determine the player's pose. The cohort-validated seat placement workflow is:

1. Open the vehicle prefab in Unity.
2. Create an empty GameObject named Seats as a child of the root.
3. Create empty GameObjects named Seat_Driver, Seat_Passenger_0, Seat_Passenger_1, etc., as children of Seats.
4. Position each seat at the local coordinates that correspond to where the player's hips will sit when occupying that seat. For most vehicles, the seat transform should be at the center of the seat cushion at hip height.
5. Rotate each seat transform so that its forward (+Z) axis points in the direction the player will face.
6. Confirm the placement visually by enabling the Scene view's "Show Gizmos" option and dragging a temporary humanoid avatar into the scene for reference.
7. Save the prefab.

Pro tip

Import a Unity humanoid avatar into the scene as a sibling of the vehicle for visual reference during seat placement. The cohort uses the Unity-provided "Ethan" reference character for this purpose; it is in the Standard Assets Characters package available from the Unity Asset Store.

Exit transforms

Exit transforms are empty GameObjects that mark where each player appears when exiting the vehicle. Each seat has a corresponding exit transform. The exit transform should be placed at the position outside the vehicle where the player will stand after exiting.

Seat	Corresponding exit transform
Seat_Driver	Exit_Driver
Seat_Passenger_0	Exit_Passenger_0
Seat_Passenger_1	Exit_Passenger_1
Seat_Passenger_2	Exit_Passenger_2

The cohort's recommendation is to place the exit transform approximately 1 meter outside the vehicle's collider, at ground level, on the side of the vehicle that the seat opens to. For a left-hand-drive car, the driver's exit transform is approximately 1 meter to the left of the vehicle at ground level.

Common mistake

Placing the exit transform inside the vehicle's collider or below the ground plane. The player will spawn inside the collider or fall through the world. Confirm the exit transform position by enabling colliders in the Scene view and verifying that the exit transform is outside every collider.

Paintable material setup

Unturned™ supports vehicle painting via a runtime shader that reads a paint mask from one of the material's texture channels. The paint mask defines which areas of the vehicle accept paint and which remain at their original color (e.g., chrome, windows, tires).

Paint mask texture

The paint mask is a grayscale texture with the following channel meaning:

Channel value	Effect at runtime
255 (white)	The pixel accepts paint at full intensity.
128 (50% gray)	The pixel accepts paint at half intensity (blended with the base color).
0 (black)	The pixel does not accept paint. The base color is preserved.

The mask should match the UV layout of the vehicle's body texture. Areas that represent painted body panels should be white; areas that represent chrome trim, windows, headlights, and tires should be black.

Material configuration

The cohort-validated paintable material configuration is:

1. Open the vehicle's body material in the Unity Inspector.
2. Set Shader to the cohort-recommended paintable shader. The cohort uses a custom shader provided by the Unturned™ modding documentation; see the official Smartly Dressed Games documentation for the current shader path.
3. Assign the body's Albedo texture to the Albedo slot.
4. Assign the body's Normal Map to the Normal Map slot.
5. Assign the paint mask texture to the Paint Mask slot.
6. Set Paint Mask UV channel to UV0 (the same channel as the body texture). If the paint mask uses a different UV layout, set the channel to UV1 and unwrap a second UV channel in Blender.
7. Apply.

Testing the paint mask

1. Load the vehicle in single-player.
2. Use the in-game paint spray to apply a color to the vehicle.
3. Inspect each area of the vehicle:
   • Body panels should show the applied color.
   • Chrome trim, windows, and tires should retain their original color.
4. If any area does not respond to paint, inspect the paint mask in Photoshop and confirm the channel value for that area.

Did you know?

The paint shader applies the player's chosen color on top of the Albedo texture using a multiplication blend. A pure white body texture under a red paint will appear bright red; a gray body texture under a red paint will appear dark red. The cohort recommendation is to author the body Albedo with neutral gray tones for any area that will be painted; this lets the player's chosen color show through cleanly.

The Vehicle.dat file

The .dat file is the parameter set that Unturned applies to the vehicle at load time. The file is a key-value text file, one key per line. Field names are case-sensitive; the cohort recommendation is to use the exact casing documented below.

The .dat file lives in the vehicle's mod folder alongside the .unity3d master bundle. See Master Bundle Export for the bundling step and Project Folder Structure and GUIDs for the folder layout.

Identity and type fields

Field	Type	Purpose
ID	uint16	The unique vehicle ID. Must not collide with vanilla or other mod IDs.
GUID	uint128	The 128-bit globally unique identifier for the vehicle prefab. See the GUID article.
Type	enum	The vehicle category. Common values: Car, Truck, APC, Helicopter, Plane, Boat, Train.
Name	string	The internal name. Should match the prefab filename.

Speed and steering fields

Field	Type	Cohort-validated default	Purpose
Speed_Min	float	-20	The reverse speed cap in arbitrary units. Negative values indicate reverse direction.
Speed_Max	float	60	The forward speed cap in arbitrary units. Cars typically use 40–80; trucks 30–50; sports cars 80–120.
Steer_Min	float	-30	The minimum steering angle in degrees.
Steer_Max	float	30	The maximum steering angle in degrees. Cars typically use 30; trucks 25; off-road vehicles 35.
Brake	float	8	The braking force multiplier. Higher values stop the vehicle faster.

Engine and fuel fields

Field	Type	Cohort-validated default	Purpose
Engine	enum	Car	The engine sound category. Common values: Car, Truck, Helicopter, Plane, Boat.
Fuel	uint16	5000	The maximum fuel capacity.
Fuel_Burn	float	1.0	The fuel burn rate per second of engine operation.
Health	uint16	1000	The maximum hit points before the vehicle is destroyed.
Explosion	uint16	50	The explosion damage radius on destruction.

Battery fields (for vehicles with battery-powered features)

Field	Type	Cohort-validated default	Purpose
Battery	uint16	1000	The maximum battery capacity. Used for headlights, horn, radio.
Battery_Burn	float	0.1	The battery drain rate per second of headlight/radio operation.

Mass and physics fields

Field	Type	Cohort-validated default	Purpose
Mass	float	2000	The vehicle mass in kilograms. Should match the Rigidbody mass.
Tire_Health	uint16	100	The hit points of each tire before it pops.
Lock_Min	float	-45	The minimum gear ratio (reverse).
Lock_Max	float	45	The maximum gear ratio (top forward gear).

Example Vehicle.dat

A minimal cohort-validated Vehicle.dat for a four-seat passenger car:

ID 2001
GUID f47ac10b58cc4372a5670e02b2c3d479
Type Car
Name MySedan

Speed_Min -20
Speed_Max 65
Steer_Min -30
Steer_Max 30
Brake 8

Engine Car
Fuel 5000
Fuel_Burn 1.0
Health 1000
Explosion 50

Battery 1000
Battery_Burn 0.1

Mass 1800
Tire_Health 100

Common mistake

Setting Speed_Max to 0 or omitting the field. The vehicle will not move regardless of WheelCollider configuration. Speed_Max is the speed cap applied by InteractableVehicle to the wheel motor torques; a value of 0 produces zero torque and the vehicle remains stationary.

Vehicle types and their fields

Different vehicle types use different subsets of the .dat fields. The cohort-validated field-by-type matrix is documented below.

Field	Car	Truck	APC	Helicopter	Plane	Boat
Speed_Min	Yes	Yes	Yes	Yes	Yes	Yes
Speed_Max	Yes	Yes	Yes	Yes	Yes	Yes
Steer_Min	Yes	Yes	Yes	Yes	Yes	Yes
Steer_Max	Yes	Yes	Yes	Yes	Yes	Yes
Brake	Yes	Yes	Yes	No	No	Yes
Engine	Yes	Yes	Yes	Yes	Yes	Yes
Fuel	Yes	Yes	Yes	Yes	Yes	Yes
Mass	Yes	Yes	Yes	Yes	Yes	Yes
Tire_Health	Yes	Yes	Yes	No	No	No
Lift	No	No	No	Yes	Yes	No
Drag	Yes	Yes	Yes	Yes	Yes	Yes
Buoyancy	No	No	No	No	No	Yes
Turret	No	No	Yes	No	No	No

The Helicopter and Plane types have additional fields (Lift, Pitch_Min, Pitch_Max, Yaw_Min, Yaw_Max) that apply only to aerial vehicles. The Boat type has additional fields (Buoyancy, Wake) that apply only to water vehicles. The APC type has additional fields (Turret, TurretYaw_Min, TurretYaw_Max) that apply only to vehicles with a mounted turret.

Testing in single-player

The cohort-validated single-player testing workflow is:

1. Build the master bundle. See Master Bundle Export.
2. Copy the master bundle and the .dat file to the local Unturned™ install's Vehicles/ mod folder.
3. Launch Unturned™ in single-player.
4. Open the in-game console with ~ (tilde).
5. Type @give 2001 (replace 2001 with the vehicle's ID). The vehicle spawns at the player's position.
6. Approach the vehicle and press F to enter the driver's seat.
7. Press W to drive forward. The vehicle should accelerate.
8. Test each handling parameter:
   • W to accelerate. Confirm the speed cap matches Speed_Max.
   • S to brake/reverse. Confirm the brake force feels balanced.
   • A/D to steer. Confirm the steering range matches Steer_Min/Steer_Max.
   • Spacebar to handbrake.
   • Shift to honk.
9. Drive over varied terrain (flat, hills, off-road) to test suspension response.
10. Park the vehicle and exit with F. Confirm the player spawns at the Exit_Driver transform position.
11. Enter as a passenger and confirm the passenger seat positions are correct.

Pro tip

Use Unturned's in-game @vehicle console command to spawn additional copies of the vehicle for stress testing. The cohort recommendation is to spawn at least three copies and drive them simultaneously (or use the @teleport console command to move quickly between them) to test how the vehicle behaves when multiple instances are active.

Diagnosing common vehicle bugs

The table below matches symptoms to causes and resolutions for the most commonly reported vehicle bugs.

Symptom	Most likely cause	Resolution
Vehicle does not appear when spawned	Master bundle not loaded	Confirm the bundle is in the correct mod folder and the .dat ID matches the spawn ID
Vehicle appears but does not move	Speed_Max is 0 or not set	Set Speed_Max in the .dat
Vehicle moves backward when accelerating	Front/rear wheel motor torques reversed	Confirm Wheel_Front* and Wheel_Rear* naming matches expectations
Wheels float above the ground	WheelCollider radius too large	Reduce radius to match wheel mesh
Wheels sink into the ground	WheelCollider radius too small	Increase radius to match wheel mesh
Vehicle oscillates after every bump	Damper too low relative to spring	Increase damper to ~10–15% of spring value
Vehicle compresses and never returns	Damper too high relative to spring	Decrease damper
Vehicle slides uncontrollably	Sideways friction Stiffness too low	Increase Stiffness toward 1.0
Vehicle refuses to turn	Sideways friction Stiffness too high	Decrease Stiffness toward 0.7
Driver sits in dashboard	Seat_Driver transform inside body collider	Reposition Seat_Driver
Driver exits inside the vehicle	Exit_Driver transform inside collider	Reposition Exit_Driver
Player spawns under the world	Exit transform below ground plane	Raise Exit transform to ground level
Paint does not apply	Paint mask channel set incorrectly	Inspect paint mask texture; confirm white in paintable areas
Paint applies to chrome and windows	Paint mask is uniformly white	Author paint mask with black in non-paintable areas
Engine sound does not play	AudioSource missing on root	Add AudioSource to root, configure Spatial Blend 1.0
Engine sound plays at wrong pitch	Engine field in .dat does not match vehicle type	Set Engine field to match vehicle category
Vehicle explodes on spawn	Explosion field set too high relative to health	Reduce Explosion or increase Health
Tires pop instantly	Tire_Health set too low	Increase Tire_Health
Headlights do not turn on	Light_Headlight* GameObjects do not have Light components	Add Light components to the headlight GameObjects
Battery drains immediately	Battery_Burn rate too high	Reduce Battery_Burn

Advanced considerations

Vehicles with destructible parts

Unturned™ supports vehicles with destructible parts (doors that fall off, hoods that pop open on damage). The cohort-validated configuration is to add separate GameObjects for each destructible part as children of the root, with a BoxCollider set to Trigger and a custom damage script. The damage script disables the GameObject when the part's hit point pool reaches zero.

Vehicles with mounted weapons

Vehicles with mounted weapons (APCs, technicals) use a Turret transform that the gunner's seat references. The Turret transform is the empty GameObject that the weapon's muzzle direction is computed from. The .dat includes a Turret block with the turret's traverse limits and elevation limits.

Helicopters and planes

Helicopters and planes use a different physics model from ground vehicles. The cohort's recommendation for aerial vehicles is to consult the Smartly Dressed Games modding documentation for the helicopter and plane prefab structure; the aerial vehicle structure differs from the ground vehicle structure in significant ways and is outside the scope of this article.

Boats

Boats use a WaterCollider instead of WheelCollider components. The boat's buoyancy is controlled by the Buoyancy field in the .dat. The cohort's recommendation for boats is to start with the Unturned™ vanilla boat prefab as a reference and to consult the Smartly Dressed Games modding documentation for the water physics configuration.

Trains

Train vehicles ride on track meshes that the modder authors separately. The cohort's recommendation for trains is to consult the Smartly Dressed Games modding documentation for the track-following script and the train prefab configuration.

Multiple seat configurations

A vehicle with multiple seat configurations (e.g., a truck that can carry 2, 4, or 6 passengers depending on whether the bed seats are deployed) can be authored as a single prefab with all seats present and a deploy state controlled at runtime. The cohort's recommendation is to author the maximum seat count in the prefab and disable the unused seats at runtime via the InteractableVehicle script's seat enable/disable methods.

Vehicle authoring benchmark

The 57 Studios cohort measured end-to-end vehicle mod authoring times across cohort members during the 2024 and 2025 cohort years. The benchmark is the time from a finished modeled vehicle (FBX in hand) to a working in-game vehicle.

Modder experience level	Median authoring time	Notes
First vehicle mod	18 hours	Includes learning the prefab structure and .dat fields.
Second vehicle mod	6 hours	Most learning is transferred from the first vehicle.
Cohort-experienced (5+ vehicles)	3 hours	Cohort-validated templates and scripts in use.
Cohort-master (15+ vehicles)	1.5 hours	Authoring is largely automated via cohort scripts.

The cohort's instrumentation identified that the largest single time sink for first-time modders is the .dat field configuration. The second largest is the WheelCollider tuning. The cohort recommendation for new modders is to start with the cohort's template .dat files (available in the cohort's reference repository) and to tune values incrementally rather than authoring from scratch.

Frequently asked questions

My vehicle does not move when I press W. What should I check first?

Confirm that Speed_Max is set to a positive value in the .dat file. If Speed_Max is 0 or absent, the vehicle's motor torque is 0 and the vehicle will not move regardless of any other configuration. The second check is whether the WheelCollider radius matches the wheel mesh radius; if the wheels are floating above the ground, the friction curve does not engage and the vehicle slides without traction.

Why do the driver and passengers sit inside the dashboard?

The seat transforms are positioned at the wrong local coordinates. Open the prefab in Unity, select each seat transform, and inspect the local position. The transform should be at the hip-height position inside the seat cushion, not at the center of the vehicle or at the origin. The cohort recommendation is to use a humanoid reference avatar to verify seat placement visually before saving the prefab.

My paint mask is white everywhere but paint still does not apply. What is wrong?

The most likely cause is that the paint mask is not assigned to the correct material slot. Inspect the body material in the Unity Inspector and confirm that the paint mask texture is in the Paint Mask slot, not in the Albedo or Normal Map slot. The second possible cause is that the material's shader does not support paint masks; confirm the shader is the cohort-recommended paintable shader.

How do I tune the suspension so the vehicle does not oscillate?

The damper value should be approximately 10–15% of the spring value. If the spring is 35000 N/m, the damper should be approximately 3500–5250 N·s/m. Values below 10% produce oscillation; values above 20% produce a vehicle that compresses on every bump and never returns to neutral. The cohort-validated default ratio is 35000:4500.

Can I have a vehicle with more than four wheels?

Yes. Unturned™ supports vehicles with any number of wheels, including six-wheelers (military trucks), eight-wheelers (APCs), and tracked vehicles (tanks). The cohort recommendation is to add additional WheelCollider GameObjects following the same naming convention with sequential suffixes (Wheel_RearLeft_0, Wheel_RearLeft_1, etc.) and to confirm that the InteractableVehicle script's wheel reference array includes all of them.

How do I make the vehicle accept fuel at gas stations?

Set the Fuel field in the .dat to a positive value. The default of 5000 is sufficient for most vehicles. The Fuel_Burn field controls how quickly fuel is consumed; lower values produce a more efficient vehicle. Unturned's gas station interaction is automatic for any vehicle with a positive Fuel value.

Why does my helicopter fall out of the sky?

Helicopters use the Lift field instead of relying on WheelCollider friction. Confirm the Lift field is set to a positive value in the .dat and that the prefab does not include WheelCollider components (which conflict with the helicopter's aerial physics model).

My vehicle's wheels rotate but the wheel meshes do not. What is wrong?

The wheel mesh must be a child of the WheelCollider GameObject, not a sibling. Confirm the hierarchy: Wheel_FrontLeft GameObject contains the WheelCollider component AND has WheelMesh_FrontLeft as a child. The cohort's authoring scripts assume this hierarchy; if the mesh is parented elsewhere, the pose update will not propagate.

Can I author a vehicle with paintable wheels?

Yes, but the paint mask must include the wheel UV islands as white pixels. Most vehicle authors leave the tires as black (non-paintable) in the paint mask because painted tires look stylistically off; the cohort recommendation is to mark only the wheel rims as paintable if the wheels should respond to paint at all.

How do I add custom engine sounds?

Replace the AudioSource clip with a custom looping engine sound file. The clip must be a Unity AudioClip imported from a .wav or .ogg file. The cohort recommendation is to use .ogg for engine sounds because the file size is smaller and the looping behavior is more reliable. See Audio Packaging for Unturned for the audio import workflow.

My vehicle has invisible windows. How do I make them transparent?

The windows are a separate material on the vehicle body's mesh. Assign a transparent shader (e.g., the URP Lit shader with Surface Type set to Transparent) to the windows material. The transparency must be authored in the windows material's Albedo alpha channel; an alpha value of approximately 80–120 (out of 255) produces a typical car window appearance.

What is the cohort-recommended starting point for a new vehicle mod?

The cohort's recommended starting point is to clone the cohort's reference sedan template (available in the cohort's reference repository) and to modify it incrementally. The template includes a working prefab structure, a cohort-validated .dat, and the cohort's authoring scripts pre-wired. Modifying the template is significantly faster than authoring from scratch.

Best practices

• Use the cohort-validated naming convention for child GameObjects. The cohort's authoring scripts depend on the convention.
• Match the WheelCollider radius to the wheel mesh radius exactly. Mismatches produce floating or sinking wheels.
• Keep the damper at 10–15% of the spring value. This ratio produces balanced suspension.
• Confirm seat transforms visually with a humanoid reference avatar before saving the prefab.
• Place exit transforms outside the vehicle collider and at ground level.
• Author paint masks with neutral gray body Albedo so player colors show through cleanly.
• Set Speed_Max to a positive value. A value of 0 produces a stationary vehicle.
• Test handling in varied terrain (flat, hills, off-road) before publishing.
• Stress-test with multiple instances of the vehicle spawned simultaneously.
• Cross-reference field-by-type matrix when authoring .dat files for non-car vehicle types.

Cross-references

• How to Install Unity Editor — the prerequisite Unity install.
• How to Export an FBX — the FBX export workflow.
• Animations Export Blender to Unity — the previous article; vehicle animations (e.g., doors opening) use the same export pipeline.
• Gun Mod Tutorial — the next article in the items section; uses the same prefab and .dat conventions.
• Master Bundle Export — the bundling step that follows vehicle authoring.
• Project Folder Structure and GUIDs — the folder layout and GUID generation workflow.
• Audio Packaging for Unturned — the audio workflow used for engine sounds.
• How to Install Notepad++ — the recommended .dat editor.
• Smartly Dressed Games Modding Documentation — the official modding documentation.

Document history

Version	Date	Author	Notes
1.0	2024-07-08	57 Studios	Initial publication. Prefab structure and WheelCollider configuration.
1.1	2024-10-14	57 Studios	Added paintable material workflow and seat transform guidance.
1.2	2025-02-20	57 Studios	Added .dat field-by-type matrix and diagnostic flowcharts.
2.0	2025-05-18	57 Studios	Major revision. Added field-by-vehicle-type matrix and cohort benchmark.

Closing note

Vehicle mods are among the more complex Unturned™ mod categories because they combine Unity physics, a multi-component prefab structure, and a parameter-rich .dat file. A modder who follows the cohort-validated prefab structure, applies the cohort's WheelCollider defaults, and uses the field-by-type matrix to author the .dat can ship a working vehicle in approximately three to six hours after the modeling phase is complete. The cohort recommendation is to start with the reference templates and to deviate only as specific vehicle types require.

Next steps

Continue to Gun Mod Tutorial for the end-to-end gun mod walkthrough that uses the same prefab and .dat conventions documented here applied to weapon mods.