Killing Floor SDK mapping guide

Everything below is a retelling of the community mapping guide written by Holy Username Batman! — the Steam version and its mdBook mirror. Credit for the knowledge, the screenshots and the swearing goes to the author and to everyone they credit inside. This page exists so the material survives even if Steam decides otherwise, and so the Russian half of the community can read it too.

Intro

The KF1 SDK is Unreal Editor 2.5 with a Tripwire hat on. It is slow, it crashes, half its settings lie to you — and it is still the only way to build a Killing Floor map. You will end up hating the tool and staying anyway, because the game is worth it.

There is a certain charm in how blunt it is. Nothing hides behind five nested tabs or a hundred hotkeys: usually there is exactly one way to do a thing, occasionally two, and once you know it you know it forever. The tools are not friendly to beginners, but they are finite, which is more than can be said for modern editors.

And yes, KF1 is an old game with a small scene. If you are reading a mapping guide for it in the 2020s, you are here on purpose.

The selection-lag patch is not optional. metallicafan212 released a fix for the editor’s infamous 10-second delay on almost every actor selection: UE2SelectionFixes v0.3-Alpha-KF. Install it before you do anything else; it turns the SDK from unusable into merely annoying.

Get the 4 GB editor. The Siren Torturers community maintains a patched KFEd that lifts the 2 GB RAM cap to 4 GB: KFEd-4gb.zip. Everyone in ST runs it, it behaves, and larger maps stop dying on memory. If downloading a patched executable makes you twitchy, the same edit can be done to KFEd.exe by hand — that is discussed in this guide.

Other starting points, depending on where you are:

• Never opened the SDK at all: Getting started with the SDK covers launching it.
• Prefer video: this Unreal Editor 2.5 playlist is decent for absolute beginners.
• Want to see a small map built end to end (minus decoration): tutorial video by the guide’s author.
• Interested in code rather than geometry: the Lazy KF Wiki is the better place to start, with the official KF Modders Discord for questions — it is a shared KF1/KF2 space, so behave.
• Want mappers to talk to: the Siren Torturers Discord still has a few semi-active KF1 mappers. There is also an unofficial KF1 modder Discord (Bungalow) that runs on invites.

Browsers: the three icons that matter

Once you have blocked out a rough shape with the cube builder and the add/subtract tools on the left, three icons near the top of the screen become your whole workflow:

A chess pawn opens the Actor Class Browser, a painting opens the Texture Browser, and an arch opens the Static Mesh Browser.

Actor Class Browser

Everything invisible that still affects the player lives here:

• pickups,
• emitters — smoke, campfires, mist,
• projectors — detailed shadows, bloodstains, decals on walls,
• triggers — doors and other player/specimen interaction,
• lights,
• sound effects.

Usage is always the same: highlight the class you want, right-click in a viewport, insert actor ‘X’.

Texture Browser

Almost every surface “wallpaper” used in KF maps. Pick one for your floor, wall or ceiling and double-click to apply. Some of them also exist as materials wrapped onto static meshes. For what the engine supports — formats, alpha, the rest — read UnrealTexturing.

Tip: install something like GIMP for custom texture work. Import and export straight through the texture browser (.dds, power-of-two dimensions) and you can filter, combine or crop stock textures with far more control, which is especially handy for meshes. There is a good texturing tutorial thread on the TWI forums.

Second tip: if you are going to live in textures anyway, learn the built-in material classes first — they work, they cost less file size and they optimise better. The Material Modifier is the simplest entry point and the UDN site map explains it properly.

Static Mesh Browser

Static meshes are pre-made 3D objects you drop into the world: doors, tricycles, radioactive mushrooms, dosh. Technically each one is an Object-class actor, and meshes can also be attached to other actors to give them a physical form in game.

You can also roll your own without leaving the editor: build a BSP structure, select the coloured brush outlines in the 2D viewports (or the wireframe in the 3D viewport), then right-click → convert to static mesh. Whatever textures you had applied travel with it into the package you choose — myLevel or a custom one.

Think of meshes as recycled objects. Build once, place a hundred copies, and the engine renders and culls them far more cheaply than the equivalent geometry.

Deep dive: assets

Static meshes

Converting BSP into static meshes is convenient, not good — complex BSP geometry is murder on map performance. Properly optimised meshes come out of real modelling software like 3DS Max or Maya, which cost money.

The alternative most KF mappers actually use: take meshes from stock maps, rescale them (keep it to about three scaled variants max, for optimisation), rotate them, and repurpose them into something new. It runs entirely on stubborn improvisation — clipping decapitated heads over corpses and calling it art — and it is dramatically faster than modelling from scratch.

There is a community static mesh spreadsheet cataloguing what exists and where. If you want to help extend it, ask in the Siren Torturers group.

Stock KF assets look better than most first attempts and they are free. Just add something of your own on top so the map is not a shuffle of other people’s rooms.

Optional: 3D modelling for KF1

Blender is free and everyone knows it, but it does not officially ship .ase or .lwo exporters, so you have to track one down: io_export_ase. Install it via Edit → Preferences → Install add-on, search “asci” in the list, tick it. After that you can build simple custom meshes and export them into KF (textures handled separately). Going the other way — KF into Blender — needs more tooling.

Other routes:

• A pile of Blender exporters and tutorials, archived: BeyondUnreal Blender page.
• Milkshape — weaker than Blender, but its built-in .ase exporter just works.
• Old 3DS Max installs, if that suits you better: setup tutorial and Softimage Mod Tool.

Once you have a .ase, .psk or .lwo file, open the static mesh browser and go File → Import → your mesh. Import into myLevel if you want players to download it with the map; use a separate named package only for genuinely large projects, since admins have to distribute every extra package.

Warning: if your mesh has multiple materials or UV sets, test the exporter early. Most of them fail on that unless you have magic fingers.

Tip: Umodel is excellent for bulk-exporting KF assets, and the same site hosts the Un+ActorX plugins for 3DS Max import/export. There is a video walkthrough as well, watchable at 3× speed.

Texture sources

Assuming you can convert to .dds and respect power-of-two dimensions, these are worth a look:

• Poly Haven
• Textures.com
• AmbientCG
• Texture Ninja
• OpenGameArt
• itch.io assets
• Poliigon — probably overkill
• Sketchup Texture Club

Making custom textures fit

If you import your own, follow the advice from the Tripwire mapping guide about final edits:

The short version: KF textures fake a bump-mapped look by overlaying an emboss-filtered greyscale copy of the base texture on itself. Lower the opacity or blur the embossed copy if it comes out too harsh. KF textures are also high contrast with grit and grime detail layers on top. Relevant GIMP emboss documentation.

While learning, lean on the game’s own assets as hard as possible. Browsing stock packages on breaks is also a decent cure for the “I know what to build but I have no ideas” state. Search engines and Pinterest have infinite reference images.

There is also an excellent in-depth guide built around one example project worth reading alongside this one.

Build and BSP holes

The build button in the top right rebuilds the entire map every time, from every brush you have ever added or subtracted. Switch to wireframe (the hollow cube icon above the 3D viewport) and you will see old brushes still sitting inside walls you thought you replaced.

So a brush is not the wall. A brush is a persistent instruction that keeps applying its effect even after later brushes carve through the same space — a skeleton under the geometry. When you edit a wall, you are moving the invisible primitive that created it.

That is a feature, and you should abuse it. In wireframe you can:

• drag a brush somewhere else if a wall is in the wrong place;
• copy corridors and floors with Ctrl+C / Ctrl+V, or better, Shift+D to duplicate;
• delete a brush entirely to reclaim that space;
• rotate a brush with the actor rotate tool;
• flip a brush between add and subtract in Properties → Brush.

Then hit build geometry (or build all) and watch every surface remould itself.

General build scale

Absolute minimum heights to keep in mind:

• standing player — 108 units,
• crouching player — 76 units,
• crawler — 56 units.

Someone else measured slightly different and probably more accurate numbers, including official-scale dimensions worth copying:

Use those as a ruler, not just a minimum. 216 units is two player heights — a reasonable ceiling. Do not even ask about minimum width: pathing collapses long before geometry does, so go 200+.

Worth remembering: UE lightmapping is tied to BSP brush size. One enormous brush is not automatically the optimised choice.

BSP holes

You have seen them, or you will. They are literal holes in your map.

Cause. The editor gets confused by overlapping brushes. Prevention beats every fix.

First rule: always work on grid 2 or above. Grid 1 is the plague.

Second: for irregular shapes or transit-style stairs, use the 2D shape editor or vertex editing instead of stacking brushes. Two videos worth watching — one, two — plus Hourences’ BSP tutorial, which has the juicy details.

A hole does not appear every time brushes overlap. Think of it as Schrödinger’s cheese: you cannot cut into a part of the cheese you already cut away, and you cannot fuse different cheese molecules back together. Holes also propagate along the x, y or z planes with some deviation, so the visible hole is often nowhere near its cause. You can create a tear, build a whole map on top of it over the following year, and only then wander into the spot where it shows.

“But I never overlap brushes.” You do — fractionally. The editor is supposed to snap brushes to grid when the setting is on, but hopping in and out of grid 1 while brushes are selected breaks dimensions or pivots. UE2 can only snap one brush vertex to grid at a time, and it is stubborn about which. Fancy vertex-edited constructs with steep angles and freehand polygons do it too.

Finding them. Use the portal view. Holes cut zones into fragments, so the zone colouring changes around them. Then switch to wireframe and look for an overlapping brush nearby along x, y or z.

Fixing them. First ask whether you need to: it is only a hole if someone can see it. They also shift around as you fix them, especially if you have a whole nest, so keep versioned copies of the map file — reverting is often cheaper than debugging.

If everything is still on grid, line brushes up exactly surface to surface, or rescale one and delete the other. If a brush sits on half-grid or worse, convert it to a static mesh, or right-click → Brush → Type → SemiSolid / NonSolid.

Last resort: the vertex editor. Right-click off-grid vertices in the 2D viewports to snap them back (credit: Broski). It is a last resort because the editor cheerfully snaps a different vertex off grid while you do it, so expect to spam it. actor align in the command box and Edit → Reset → Brush → All exist too, but neither is reliable.

Often the fastest move is measuring with Ctrl + middle mouse in a 2D viewport and replacing the brush outright.

Community habits that prevent all of this

Be a neat freak. Grid 1 is officially the plague. Keep file versions. Autosave. When something does break, portal view first, then wireframe, then fix the spot where you were careless.

• Static meshes are not BSP and can never cause a hole — for decoration they are the right answer 99% of the time.
• If a mesh will not do because lighting on that object matters, use a semi-solid or a non-solid brush plus a blocking volume, and reach for real BSP last.
• If a wall can be two large brushes instead of eight, that is usually better — but lightmapping is based on BSP size, so keep the cuts roughly equal. Vertex and 2D shape editing remain the best tools here.
• Pick one big grid size that covers ~90% of your map’s BSP (32 or 64 is typical) and work in multiples of it. Doorways may force you to halve it; leave everything else alone.

Vertex editor

Better than its reputation. Turn vector snap on first:

Say a brush is too big, or too regular to marry up with a neighbouring room or mesh. Then:

• select the brush;
• Ctrl + Alt to drag-select vertices (not in the 3D viewport), or Ctrl + click for a single corner;
• Ctrl + Alt + Shift to keep adding to the selection;
• edit in a 2D viewport, hiding actors for visibility.

Never turn vector snap off, and do not go wild with angles, unless you actively want BSP holes and the void between dimensions.

Known bug with triangular BSP:

That looks like jagged primitive collision. One fix is subdividing the BSP horizontally; in this particular case the pathing was remapped so zeds jumped outwards from each pillar rather than between them.

Lighting

Right-click anywhere in the map to place a light. Placement is judgement, but three settings do most of the work.

A small radius with high brightness reads as a bright orb in the dark. Moderate brightness with a large radius fills a room with ambience. Everything else is taste. Look at Waterworks if you want a reference for what the engine can do when someone bothers:

UE light tracing is bad. Really bad. If building lighting flattens one of your lights into nothing, add more. Plenty of mappers stack several lights in the same spot with different colours, radii and brightness. Official maps tend to scatter many small sources to highlight specific spots, fake more accurate falloff from a light mesh, and build atmosphere.

Naming trap: the float property Display → ScaleGlow has nothing to do with ambient glow. It scales how lighting interacts with the whole mesh’s UV. Skybox or pipe mesh blowing out next to adjacent BSP? Lower ScaleGlow. It is far simpler than material modifiers, tiny light radii or Special Lit tricks.

Use RGB8 lighting in the build settings — better looking and better optimised than DXT3. Evidence here.

The SDK jacks gamma up permanently on launch. Add -nogamma to Steam → game properties → launch options, or launch KFEd.exe directly.

You will find light properties named torchflicker, phase and similar. Leave them alone — Light Effect has never worked in game, however convincing the SDK preview looks. For an actual flickering or pulsing light, find Trigger Light in the actor class browser, insert it, and play with Light Type, Phase and Period.

Broken lightmaps? BeyondUnreal: lightmap errors.

Coronas

Coronas are lens-flare textures applied to lights so the light mesh feels alive. They are also massively overused, which is why a lot of players disable them in settings.

There are presets in the actor browser, but the manual route is usually better. Place a normal light, then:

• Properties → Light Color: set brightness to 0, pick the hue and saturation you want.
• Properties → Lighting: high radius, Corona = True.
• Properties → Display → Skins: apply a suitable texture — Departed_T has a few.

Bloom

Bloom is the cheap-but-pretty glow effect KF exposes as an optional display setting, inherited from Tripwire’s Red Orchestra 2 code base. Credit to jk for digging up the original TWI adaptive bloom thread. The settings are per level, in View → Level Properties → Bloom, and can be tweaked live in practice mode via console.

Before tuning anything, reset the game’s gamma, brightness and contrast to default in the graphics menu. A level tuned against your personal gamma will look blown out or muddy on everyone else’s monitor.

Five settings drive it:

Contrast — postfxbloom_bpcontrast x. Default 1.0, min 0.0, max unbounded (do not go past ~3.0). Multiplies the pre-blur blooming image, scaling the levelled image from the previous step. Above 1.0, lower-brightness colours start blooming as well.

BlurMult — default 1.0, min 0.0, max unbounded (again, ~3.0 in practice). Multiplies the post-blur blooming image, so it controls how bright the final bloom is once added back onto the render. Values below 1.0 give a softer bloom and stop high-detail bright areas from whiting out. (The original quote lists postfxbloom_bpcontrast for this one too, which is almost certainly a copy-paste slip in the source thread.)

Ratio — postfxbloom_ratio x. Default 0.5, range 0.0–1.0. Roughly the share of the screen that should be blooming at any moment. It adapts per frame against an accumulated average screen illumination, then gets clamped by the min and max below. 1.0 means every pixel tries to bloom, 0.0 means none.

RatioMinimum — postfxbloom_ratiomin x. Default 0.0, range 0.0–1.0, never above RatioMaximum. Floors the adapted ratio. Raise it if your bloom vanishes whenever the player looks at something bright that should still glow. At 0.2, roughly 20% of the screen keeps blooming even against a pure white scene.

RatioMaximum — postfxbloom_ratiomax x. Default 0.5, range 0.0–1.0, never below RatioMinimum. Caps the adapted ratio. Lower it when objects bloom that never should — high-contrast pebbles on the ground, for instance, where the effect sometimes reads as specular highlight and sometimes just looks daft.

Dynamic lights

Manually triggered lights do work; only players who disabled dynamic lights will miss them.

Grab a TLight from the actor browser, set it up, then Properties → Object and enable Trigger Toggles. Give the light a tag like you would a mover and fire it from a matching event. Build lighting and you are done — though shadows will be far weaker than on normal lights.

Examples in official maps: in KFO-Transit the first keycard door kills a small red light and turns on a green one. KFO-Foundry goes further and uses a scripted trigger to spawn a corona headlight actor (a preset corona), usually after a bonus objective is satisfied.

Fog and the TWI override

For fog, first disable Tripwire’s broken override. The setting in Zone Info does nothing, so use KFSPLevelInfo instead:

Side effect: this also stops zeds spawning in the editor’s quick-play mode (solo and live games are unaffected). If that gets in your way, re-enable spawning in Edit → Level Properties:

Then place a Zone Info actor, enclose the room with zone portal brushes, and set:

ZoneInfo Properties → ZoneInfo → DistanceFog = True

Colour, fog start and fog end live in ZoneInfo Properties → Distance Fog.

Fog is mainly an optimisation tool outdoors, but plenty of maps use it for mood — tinting ambience, darkening a scene (dark grey around 1:24:24:24 is a decent start). Test it thoroughly; bad fog looks awful fast. Note also that fog boundaries between rooms are broken: the game switches on player location, not line of sight.

Ambient light lives under ZoneInfo Properties → Lighting. It looks ugly. Leave it.

Two more habits. Every light looks slightly flat without a corona, but a corona on every light in a small room is unbearable — decide which lights carry the scene. And simulate bounce light with small extra light actors, otherwise shadows come out pitch black; Ferenos overdoes it somewhat and is still worth studying.

Level design

Level design is an art and the learning curve is permanent. If your first map looks like trash, so did everyone’s. The feeling that it is never good enough does not go away either — look up imposter syndrome — so the important part is having fun.

If you want the clickbait version of this section, there is a decent list of level design tips and tricks.

You need a theme

Browse your camera roll, Pinterest, Getty Images, historical eras and events, memorable places, films, books, other games. Pick a setting and a theme — wintry maze, horror dungeon, whatever — and consider anchoring it to an emotion: curiosity, dread, comedy. Then build a mood board out of reference images.

Two practical notes: KF wants grit, and cataloguing software helps. Allusion and PureRef are both free; there is a short video on using them.

Planning

The standard game-dev rule applies: every asset supports the theme, the narrative or the core mechanic. If a fancy church cloister does not belong in map A, write it in a notepad and build map B around it later.

Turning a plan full of rectangles into an actual theme is where the experts earn their keep — worth watching this and this, plus one more for objective maps.

Remember the lightmapping rule while planning: lightmaps are tied to BSP size, so larger rooms should be split into roughly equal brushes as you build.

Sketches and rough 2D blueprints help enormously. Here is an early plan for a KFO map — see what it is missing:

Dimensions

Plan like an architect drafting blueprints, not like someone eyeballing cubes. It pays back later.

Keep everything simple and wide: over 200 units for walkable meshes, over 256 for BSP. That helps both the player and the extremely stupid specimen pathing.

Build in sightblockers while you are at it — good level design optimises itself. Valleys, walls and fat decorations double as antiportals and cut render load:

Greyboxing

Build the whitebox: basic geometry, doorways, spawns, paths. Then focus entirely on how it plays.

Are there a dozen dead ends? Role-play as a first-time player — what frustrates you? Ignore meshes and decoration for now; once you start decorating you mostly copy-paste anyway. Stress-test the pathing with a wave 10+ spam. Can you mix interesting routes without breaking KF pathing (you cannot, but try)? Can you punch holes in walls to open up a compromise?

Always underestimate KF pathing.

Custom assets and lighting

As a beginner, or with 2010-era software, you are unlikely to produce your own meshes — stick to custom textures and sounds. Keep a test map for combining and scaling assets in isolation.

Lighting is powerful and also a crutch, so do it last. Pick a hue that supports the theme and work saturation and brightness around it.

Two exceptions: if you already know your theme, doing lighting before texturing is fine. And if you need reliable pickups, KFSlot_Ammo_Pickup from Frightyard gives 100% consistent ammo spawns on every difficulty (credit: braindawg).

Easter eggs

Easter eggs reward exploration and make people look at your decoration. KF-SawnOfTheDead is the gold standard:

It plays on everyone’s shared hatred of sirens, uses only stock decorations plus a projector disguised as a shaft of light, is well optimised, and needs no extra downloads.

Guide the player. Interactive and important parts of a map — doorways above all — need to be highlighted: brighter lighting or projectors, pickups as breadcrumbs, meshes like pipes and fences, distinctive textures, or lines of geometry that lead the eye. Sound counts as a guideline too. Players are dumb; leave more than one clue.

Collision

Bumping into meshes and invisible walls sounds like a minor concern. It is not — it decides whether your map feels solid or broken.

Nearly every mesh already ships with collision set up. Properties → Collision lets you edit what it collides with:

• NonZero Extent — living things: players and specimens.
• Zero Extent — bullets, axe swings, projectiles.
• Projector — flashlights, blood stains, projected textures.
• Actor — dosh, emitters, assorted objects.
• Plus the self-explanatory rest.

Set them True or False as needed. That part is genuinely simple.

The harder question is blocking an area for players but not zeds, or fixing a mesh whose own collision does not cut it. KF1 specimen pathfinding is bad enough without players on rooftops or wandering into spawn points, so you want collision volumes.

Use them thoughtfully. Normally you place a mesh or platform that visually “blocks” the route, then extend a blocking volume well above jump height. Otherwise a player walks up to ordinary-looking ground, hits an invisible wall, gets cornered by zeds and dies annoyed. Do not break immersion.

Blocking and ZedZone volumes

If you can shape a brush, you can shape a volume: mould the shape you want, then instead of subtract, use the translucent blue cube tool and right-click it. Plenty of options appear; two matter here.

• Blocking Volume — blocks players and specimens (all NonZero extent). Under Properties → Collision → Class Blocker you can block specific classes instead, like KFMonster or dosh actors.
• ZedZone Volume — blocks players but not specimens by default. Useful around spawn points.

For examples of overuse, open some lesser-known custom maps or KF-Stronghold in the SDK. Underuse looks like this:

Triggers

The actor browser has an assortment of triggers, and not all of them work reliably in KF. The two that everyone actually uses:

• KFProxyTrigger — actor class browser → Trigger → Trigger
• KFUseTrigger — actor class browser → Trigger → Use Trigger

Usage:

1. Place it sensibly. A KFUseTrigger belongs centrally in a door; a proxy trigger goes on or beside whatever matters.
2. Properties → Events: name the event something short and unique, e.g. Door1A.
3. Give the target actor or mover a Tag with the same name.
4. Done. This drives sound effects, scripted triggers, objectives and movers alike.

Right-click the border of the 3D viewport → Actor → Radii view to see a trigger’s range as a red sphere — most useful for KFProxyTrigger. Its size lives in Properties → Collision → collision radius / collision height.

Plenty of other actors fire events as a side effect of what they do — movers especially. Listing them all would double this guide; they work identically. The trick is chaining tags and events together, e.g. an alarm sound fired by a door opening.

Two more: the shoot trigger works (KFO-RE-Mansion and KFO-WestLondon use one) but is fiddly. And KFMusicTrigger exists — no vanilla map uses it, so copy one from a custom map to see how it is wired.

Movers

Doors, elevators, anything that moves — those are movers, and they are limited to linear motion. Anything more advanced needs an animation.

In principle it is simple: give the mover numbered key positions, then tell it what makes it move. Start by assigning a mesh as a mover.

Building the mover

Highlight the mesh you want in the mesh browser, then click the rectangle-with-four-arrows icon above. Right-clicking that icon offers the advanced mover types.

The SDK drops a normal-looking mesh near your active red brush. Move it to its starting position, then right-click → Mover → Key 0. That records the start. Right-click again and choose Key 1, then move or rotate the mover to where it should end up — the SDK records the transition linearly. More complex motion means Key 2, Key 3, and so on.

Telling it when to move

Three property groups matter:

• Events — the mover’s Tag, linking it to whatever triggers it.
• Mover — how long it takes to travel between keys, plus delays.
• Object — what makes it move and how.

Vital details:

• KFUseTrigger works exclusively with KFDoorMovers.
• Encroach decides what a mover does when a player or specimen is in the way. “Ignore when encroach” can phase things through objects and players.
• StayOpenTime (under Properties → Mover) sets how long the mover holds its final key position; there is also a preconfigured mover setting under Properties → Object that runs to the final key and returns to Key 0 after a delay.
• Trigger Toggle runs through every key in one motion to the last one, and only walks back to Key 0 on a second trigger.

The rest is tedious to enumerate — the UE2 movers tutorial and Lode’s mover guide cover every setting.

Pathing

In theory: right-click in corners and along corridors, insert path node, done. In practice, no.

On the top border of the 3D viewport: right-click → View → Paths, then Build All or Build Paths. You get a colourful map of the routes zeds can take:

Colours tell you how good each route is:

That table came from UE3 documentation because UE2 documentation is scarce, but it has been checked repeatedly against the UE2 site map and against the editor.

If a path is blue, rearrange geometry or navigation points until it turns green. Keep node placement clean, keep lanes wide, place nodes only where they are needed, and leave room for a crowd.

If zeds fall off stairs or platforms, suspect misplaced path nodes, a route that should be proscribed, or a section that is simply too narrow. Or add railings.

And sometimes bad pathing is the feature. In KFO-BossArenaNerf zeds occasionally drop off platforms despite a clear route — and watching a Patriarch charge you and then fall off a plank inches from your face is genuinely great.

Spawn points (zombie volumes)

Same workflow as BSP: size and position your active builder brush first, then click the volume tool:

Unless you are building a KFO map, leave the Tag alone and go to Properties → ZombieVolume:

Properties worth editing

Defaults work fine, but five settings are worth knowing.

1. AllowPlainSightSpawns. Roughly 80% certain the code does what it says, but enabling it never hurts during setup and testing. Worth leaving on in release when a spawn is genuinely hidden anyway, because spawn volumes are terrible at recognising static meshes as sightblockers.

2. MinDistanceToPlayer. Straight-line x, y, z distance below which proximity disables that spawn.

3. NoZAxisDistancePenalty. Stops height counting toward that disabling distance. Enable it when zeds drop in from far above.

4. SpawnDesireability. KF runs its own mostly distance-based algorithm to pick spawns; this biases it. Default is around 3000. Raising a neglected spawn to 4000 during testing is reasonable; going below default rarely is. Balance matters.

5. OnlyAllowedZeds. Exactly what it says, and it genuinely works. Useful for small volumes — big enough for Stalkers, not for everything — or for banning Bloats when pathing is borderline blue.

Two more habits: routes out of a zombie volume should always be green, because specimens are fragile right after spawning and need wide lanes. And partial distance fog counts as a line-of-sight blocker even when it is not opaque, as do blocking volumes.

Spawn troubleshooting

• Right-click the viewport header → View → Paths and confirm your path has not deleted itself. It happens.
• Raise CanRespawnTime — 3.0 is a sane absolute minimum.
• Return other settings, SpawnDesireability included, to defaults.
• Use vertex editing to enlarge the volume (and the room around it).
• Add sightblockers or shrink the volume, assuming bAllowPlainSightSpawns does nothing.
• Then consider a forced path.
• And when debugging gets boring, building a fresh volume very often just works.

Terrain

Getting it to work

Start from the official terrain creation page.

Summary: you need a “room” sealed off with zone portals (or standing alone), with a ZoneInfo actor inside. In ZoneInfo → Properties, set TerrainZone = True. Without that step terrain will never work.

Then pick the texture you want, highlight it, open the terrain tool on the left and choose make new terrain (the new-page icon). Name the heightmap texture and put it in myLevel. That creates a TerrainInfo actor at your camera position.

Stay in the terrain tool, switch to the Layers tab, and create a new layer (new-page icon on the right). Documentation says to leave the new layer’s properties at default — but KF loves to set U Scale and V Scale to 0. Those are the tiling scale of your terrain texture, so 0 means your terrain exists, works, and is completely invisible.

Sculpting

Once it renders, the terrain editing page covers the tools.

The practical route is the paint brush followed by smoothing, at strength a little under 50:

• Ctrl + left click raises hills and mountains,
• Ctrl + right click carves valleys.

If a hilltop turns out well but too small, select it all with vertex edit (Ctrl + M1, then Ctrl + M1 + M2) and drag upwards — that raises every selected node, after which you will need smoothing and painting to fix the transitions.

Expect pain. Terrain editing is roughly 10× laggier than the rest of the SDK and crashes about three times as often.

Terrain bug checklist

TerrainZone in the ZoneInfo actor must be True:

And TerrainInfo → Properties → TerrainInfo → Layers → Layer 0 must have a texture applied, an AlphaTexture heightmap for that layer (the SDK maintains this automatically), and positive U Scale and V Scale:

If terrain is built, everything above is correct and it is still invisible: open the terrain tool, select your layer under Layers, choose “paint”, and paint the layer’s texture onto the terrain with Ctrl + M1.

Layers

Once the shape is right, blend multiple texture layers using the terrain layers page. Deco layers are worth reading up on there as well — the UDK Two site map is usually accurate for KF SDK, which is why it appears in this guide so often.

Scripted triggers

Scary at first glance, simple in practice. Find them in the actor browser under Keypoint → AI_Script → Scripted Sequence → Scripted Triggers.

Right-click for properties, then AI Script → Add. The dropdown shows everything a scripted trigger can do. Chain a few actions together and you have something close to blueprinting — enough manoeuvrability to drive story and objective maps.

The commands worth learning first:

Important: all hidden actors are destroyed by the host at game start, meaning the host reads and stores scripted trigger scripts before gameplay begins. Destroying a scripted trigger actor mid-game therefore does nothing. A GoTo loop either runs forever or has to be ended deliberately with “If” commands or by disabling the script.

For a worked example, open KFO-BossArenaNerf in the SDK and work out what it is doing. Official story maps are also excellent reading.

KFUseTriggers are for KFDoorMovers and nothing else. Scripted triggers ignore their events, as does everything else. A name like KFDoorTrigger would have saved a lot of people a lot of time. Workaround: if you need the use key to fire a scripted trigger, place a standard Trigger actor instead and set bUseTrigger = True in its Object tab.

Zone Info: sky, terrain, fog

If you are new to the SDK, the safest advice is to not touch ZoneInfo at all — most of the trouble it causes is Tripwire’s fault rather than yours, but it is still trouble. The actor lives under Info → ZoneInfo.

A zone is any space you have sealed off from the rest with portals — hidden actors, not teleporters, though technically they can act as one and it looks terrible. ZoneInfo lets you edit that zone’s properties. Without one, the game applies defaults.

There are plenty of reasons to use it — ambient brightness, multiple skyboxes, universal mesh cull distances — but UE2 is temperamental, so in practice use it for three things: terrain, skyboxes and distance fog.

Terrain. If terrain does not appear in a zone, set ZoneInfo → TerrainZone = True. With it on, terrain that cuts through other zones via a cave or entranceway renders properly. Without it: invisible and non-solid.

Skyboxes. A skybox is an isolated room providing a live 360° feed of the sky around your map. Insert the child actor SkyZoneInfo — the “camera” for the skybox. Build it, position it inside the skybox room, and you normally never touch its properties again. Be aware the camera is heavily zoomed in.

Distance fog. Enable with ZoneInfo → DistanceFog = True, then tune:

DistanceFogStart
DistanceFogEnd
DistanceFogColor

A smaller gap between start and end means thicker fog. A negative start value is legal if you want to get creative. Colour takes byte values 0–255 for hue, saturation and brightness.

KillZ — don’t. If you end up with a giant void beneath your terrain, ZoneInfo → KillZ will technically kill anything that falls below a given coordinate, but do not trust it. Use vertex editing, a KillVolume, or both. KillZ is a last resort for mappers watching zeds sink into the abyss and rave down there at the cost of your framerate.

Known hiccup: translucent meshes can block emitters and other translucent materials in your skybox when viewed through BSP — fog and clouds especially. There is no known fix, so test early and preview often.

Objective mode

If you are reading this section you are in for a world of pain. Here is how to reduce it.

The objectives

Objectives must be named, and the first one is always called start. Open View → Level Properties (or F4) to declare the expected order of objectives by name. That is the easy part.

The most significant actor is KFLevelRules_Story, found under Actor Browser → Info → LevelGameRules → KFSPLevelInfo. It sets the general rules: player starting equipment, maximum zed count (default 32), starting cash and cash bounty, and the shop.

Objective mode is a set of triggers and events you wire up yourself, like story mode but slightly more automated, with a semi-functional HUD and a peculiar aggro system. Plan what you want to happen first, then work out the wiring: which actor causes an event, when it fires, what it does.

Worth doing a small KFO project to learn the ropes before moving to a KF- story map — a story map does everything except wave and squad designers, so zed spawns need more manual work unless you write a mutator.

Designing objectives

KFStoryObjective is the mother of KFO. Three property groups matter.

Objective Conditions — normally what the player must do or avoid, though they do not have to be visible at all; you can disable the HUD and use hidden event triggers instead. When every success condition with progress importance normal is met, the objective is won; when the failure conditions are met, it is lost.

Setting progress importance: critical on a condition means that satisfying it at any point advances the map to the next objective regardless of the other conditions. Note also that a team wipe is always a loss — it is built in, so you never add it to failure conditions, which leaves room for alternate routes.

Objective Actions — what happens on win or loss:

• Win Game
• Lose Game
• Go To Last Objective
• Go To Next Objective
• Go To Objective “(name)”
• Reset Current Objective
• Restart From Checkpoint
• Random

Objective Events — triggerable events when the objective is activated, completed, deactivated or failed. Explosions, doors, sound effects, zed waves, scripted triggers, anything.

Trigger ObjCondition

Condition is a genuinely powerful scripting tool. For anyone who codes, it is your IfCondition — which means you can build non-objectives with no HUD at all and use them as general logic.

World hints

In anything resembling a story map, players get lost. World hints are text, textures or both, floating in the world as guidance — the gold bar markers in KFO-Steamland are the canonical example.

IgnoreWorldLocHidden is the setting everyone misses. Keep hints short. They are unreliable on dedicated servers, so either test on a real server or use a static mesh mover (graffiti-style) instead.

The hint is visible from everywhere in the map, so gate it behind a non-objective condition triggered by an event — a ProgressPct event from the objective condition area, with “require full team” set to false, works well.

Dialogue actor

Copy-paste one from an official map. Things to know:

• display length scales with the number of characters,
• a sound file’s duration overrides that,
• allow roughly 1.5 seconds after the end of a line before triggering the next one; it is sensitive, and a scripted trigger is easier for timers.

Cutscenes

See the endings of official maps or Mansion.

KFSceneManager:

Cinematic camera:

Odds and ends

Not covered above: objectives can be triggered while not in play, objective conditions can depend on other conditions inside KFStoryObj, and the wave and squad designers control which zeds spawn from which zed volumes.

For welder objectives, copy the KFStoryObj actor from an official map. They do complicated things — unique actors, two or more conditions per welder box, HUD wiring — and rebuilding that by hand is not worth the misery.

For objectives that need a volume, any volume works as long as you enter its name (Properties → Object → Name) into the objective condition. Use the standard Volume: the dedicated objective volume has extra code that spams “Forbidden!!!” in chat if anyone walks in before the objective is active.

Further reading: a guide covering wave and squad designers, the Tripwire wiki objective mode page for progress events, and the Containment story map tutorial.

Bugs

• Wave designers support one wave per actor. They will look like they should handle more, and they will work maybe 10–30% of the time. Spam wave designers instead.
• Zeds dying on spawn? Disable killStragglers on the level rules actor. If that fixes it, congratulations; if not, you have a pathing problem.
• The KFO HUD — objective name and details in the corner — deletes itself after roughly 30–60 minutes of uptime for no discernible reason. You can reproduce it consistently on KFO-30WaveChallenges. Do not put progression-critical information there.
• World hints also conflict across maps. Client-side you may see a community map’s hint replaced by an official KFO map’s hint, or by whichever KFO map you played last. Being told to collect a non-existent gold bar is a normal Tuesday.

Porting maps to UE3

UE3 has a polygon limit on map import: 65535. So: batches.

There is a TWI forum thread with more.

How much work porting is depends heavily on the source game, and it goes best when the source has a proper mod kit — an SDK, Hammer, that class of tool.

For Dungeon Defenders, the approach is: grab every asset related to the map inside DD’s DDDK and move them into a new custom package. Moving rather than copying auto-assigns material directory references to the new package. Never save changes back into the game’s default UPK packages. DD runs on an older UDK (UE3), so grabbing materials, textures and packages is comparatively painless — but categorise everything as you go or you will lose track fast.

KF2 is a newer, heavily modified UE3, so the obvious idea — load the packages straight in — does not work. The KF2 SDK will throw a wall of errors: UPK structure mismatches, broken mesh renders, particle FX crashes.

The main culprit is old mesh renders. Extract the UPK raw, take the PSKX, import it into 3DS Max with the ActorX plugin, and export as FBX (2014/2015). That version matters — get it wrong and the KF2 SDK crashes.

Once packaged, build the map slowly. Export selected meshes from DDDK as .t3d so they auto-place correctly in the KF2 SDK. If it crashes, one of those meshes is bad — which is exactly why you import a few at a time rather than watching the SDK die on memory allocation. Then rebuild everything: lighting, pathing, volumes, all of it.

There is a slightly more efficient route, documented by Steven, with support available in the KF Modders Discord:

• Word document tutorial
• Video walkthrough

Optimisation

Optimisation here means two things: fewer polygons and effects on screen at once, and less strain on hardware for more player FPS.

Before anything clever: keep the number of distinct static mesh instances down, which mostly means keeping copies of a mesh at the same scale. Rescaling is brilliant for reusing assets creatively, and it also means more calculation, less performance and a bigger file.

Reducing polygons

One route is converting additive brushes to semisolids via the special brush builder or right-click → Type. Hourences’ semisolids tutorial explains when that is appropriate.

The other route is rendering less of the map at once — smart level design, plus portals and antiportals.

Portals

Open any stock KF map in the SDK and you will see textured sheets across doorways, arches, windows and room seams that never appear in game. Those are portals.

Portals define zones: areas whose assets always render while the player is inside. Anything in another zone and out of line of sight can be culled.

To create one:

• build a sheet with the Sheet Builder tool (next to the cube builder),
• position it, ideally as a perfect fit to the window or doorway,
• apply the Portal preset with the Special Brush tool.

Alternatively, tick the Portal flag in a planar brush’s surface properties. Both work.

Fitting them precisely is awkward because UE will not tell you a selected brush’s dimensions. Ctrl + middle mouse draws a ruler; beyond that, writing down your common door and window dimensions in a notebook in advance saves hours.

Antiportals

Another Special Brush preset, and conceptually the inverse. Portals define what is visible; antiportals define what is not, culling only objects that are completely obscured.

Place them inside terrain, walls or large meshes. Anything they fully block stops rendering.

Never place an antiportal inside additive BSP or solid space.

Emitters

Particle systems are the single largest performance drain in KF maps. Use them sparingly and keep the settings restrained. You can try attaching their visibility to ZoneX → Object → Name, which half-works — KF-Wyre manages it.

Collision

(Credit to Fel’s guide.) Static meshes with collision, nonZeroExtent especially, cost a surprising amount. If a mesh does not need it, turn it off.

Doing that mesh by mesh is unbearable, so select in bulk:

• chandeliers do not need collision → right-click → select all of this static mesh type → collision off;
• meshes in blocked-off areas do not need collision → select all meshes in the zone → collision off.

Cull distance

Every mesh has Display → CullDistance, the distance beyond which it stops rendering. Lower means faster. Players on weak machines may override it in their settings; optimise for the majority anyway.

Shift + middle mouse draws a ruler in the 2D viewports for measuring these distances. For awkward cases, resize the builder brush until it spans the gap and read that.

Check the log

Some lag comes from things you cannot see:

• inactive KFO conditions still drawing HUD,
• destroy-actor loops,
• scripted trigger or mover loops,
• Karma decorations.

Extra measures

• Apply Engine.Black texture to BSP surfaces players will never see — spawn interiors, roofs, doorway backs hidden behind mesh frames.
• Use Display → LOD Bias (the distance LOD scaling override) on mass-produced or unremarkable meshes.
• STAT RENDER in the console shows the live polygon count on screen.

The framerate trick that should not work

Sometimes nothing helps and then something absurd does: cut all the meshes, save the map, reopen the editor, paste them back, rebuild. That has been observed to roughly double framerate.

Before:

After:

According to OldUnreal, the engine’s mesh batching can break, forcing it to reload meshes individually per instance. Cutting and re-pasting rebuilds the batching.

Further reading: how to optimise your map.

One afterthought: in UE5 terrain, components duplicate adjacent vertices, adding data and costing performance. That likely holds for UE2 as well, meaning larger terrain sectors are better optimised but may worsen collision — a trade-off worth testing rather than assuming. Similar settings exist on kfFluidActors. Having tried it: unless you are committed and technical, do not bother.

Testing

Untested maps are garbage maps. No exceptions.

The game controller icon at the top of the SDK gives you a quick test, and it is great for spot-checking. For anything that matters, test in Killing Floor → Solo instead, for two reasons: you can apply mutators like fakedplus to check spawn scaling and balance, and you will be playing at perk levels you actually recognise.

Take notes while testing, and vary what you do — you are testing, not playing Biolabs. Swap perks, try different hold spots, watch what happens. Near release, do bump tests: walk along every wall and railing looking for places you get stuck, and fix them with blocking volumes.

Server testing

If testing in game is twice as useful as testing in the SDK, testing on a server is several times better again. Set up a local dedicated server if you can, learn how port forwarding works, and drag friends into it.

It matters because:

• some bugs only appear on dedicated servers,
• if your map does well, 90% of players will meet it on a dedicated server,
• it surfaces compatibility issues with common mutators,
• you experience the map with a team,
• and testers will nag you about collision, spawns and pathing until it is all fixed.

Useful resources: server setup guide, 48-hour free server trial at PingPerfect, cheap VPS hosting at Contabo.

Testing with bots

For solo testing, this mutator is worth having: KF Bots. Extract into the Killing Floor System folder. They are noticeably less stupid than the official ones.

Console commands

Standard, for solo or as a server admin:

Custom ones:

Tips and hotkeys

Stability and setup

• Save copies often. The software will crash. The SDK renders far more than the game does, which makes it hungrier than Killing Floor itself. Getting memory crashes? Lower the in-game graphics settings — the editor inherits them.
• Log viewer: View → Log. It records SDK errors and warnings as they happen and is invaluable when debugging or modding.
• Autosave: the SDK keeps ten files from the last two hours in your maps directory, named auto0 through auto9.
• Gamma: the SDK permanently raises gamma on launch. Add -nogamma to Steam → game properties → launch options, or open KFEd.exe directly.
• Compatibility mode: right-click KFEd.exe → Properties → compatibility. Windows XP (Service Pack 3) and Windows 8 are the two that help most.
• Cut-off windows: many property windows are clipped and cannot be expanded. Try 800×600 resolution.

• If the surface properties window opens with all its text and buttons shoved off to the left, the fix is to open User.ini, delete the entire [WindowPositions] block, save, and reopen the SDK:

• 4 GB SDK (KFEd): download, removes the RAM cap.

Navigation and workflow

• Ctrl + Alt + M1 = selection box, in the top, front and side views only.
• A lot of things can only be moved or interacted with while holding Ctrl. Try that when something refuses to budge.
• Texture info: right-click a wall or surface → Properties. The top of the window shows the texture name and package path.
• Actor info: Properties → Display → Mesh shows the name and directory of the selected static mesh.
• Skins: Display → Mesh → Skins → Use applies a new texture over a mesh — graffiti over a grime or shattered-glass mesh, for example. For graffiti and reskins, do not forget this boolean:

• Big maps make the editor sluggish. The orthographic views (top, side, front) cope far better than the 3D one. In the 3D viewport, zoom in so it renders as little as possible.
• Ruler: Shift + middle mouse. Whole years have been wasted counting tiny grid squares instead. More tricks in this thread.
• Shift + D (duplicate) beats copy-paste almost every time.
• Bulk selection saves enormous amounts of time on large maps:

You can also select all actors of a type, all adds or subtracts, all brushes, or everything in a group via the group browser.

• Reveal hidden actors. Official map authors sometimes hide their work in the editor. This tool unhides it anyway:

• Right-click the viewport header to customise what each viewport shows — useful for paths above all:

Niche fixes

• For genuinely stubborn BSP holes: right-click the offending brush → Type → convert to semi-solid or non-solid (plus a blocking volume). Then try Build Options → Lower BSP Cuts.
• Test specifics regularly. Most problems are not visible at a glance.
• Slippery floors: forum tip.
• Be careful scaling static meshes — every scaled variant gets saved into myLevel as its own mesh. Custom meshes you make should live there too, since myLevel downloads with the map.
• KFUseTrigger only works with doors — confirmed here. Use a Trigger, a ProxyTrigger, or Mover → MoverEvent instead.
• Launch pads and knockback effects: forum guide.
• Custom lobby camera for your map: TWI forum tutorial.
• There is a hard limit on actors such as lights and navigation points, at ambiguous but large values. Compare your map against something like KF-Hive to gauge how much headroom you have. Beyond that, split into multiple maps and chain them with a map change command in scripted triggers.

Tripwire’s colour correction oversight

Broski of Siren Torturers dug this one up:

There is code to disable KF’s colour correction in the standard KFLevelRules, but due to a typo (KFLevelRule.) and an oversight in the KFLevelRules code — it is missing the boolean entirely — it is not usable. The colour correction options in ZoneInfo do nothing either; same exact code.

One thing does still carry the working code: the story mode actor. And it works, with massive impact on how maps look. You can use different lighting themes far more accurately.

To see the difference, drop KFSPLevelInfo into a default map and set levelInfo->bUseVisionOverlay to false.

That is the same actor and setting shown in the fog section above.

Community advice

• Unless you actually have custom texture or mesh packages, always answer no to the save prompt — never save myLevel:

• Asset naming conventions the good KF creators used: version mismatches and you.
• Study official maps. They know what is stable and what is optimised.
• Extra SDK functionality via a customised actor list, documented here — unrealed.ini is sensitive, so be careful.
• Do not touch this cursed SDK without music or a podcast running.
• The holy grail of BSP basics is the 2D shape editor video, particularly from about 2:02 to 5:00.

Hotkeys

Extended list: UnrealEd keys.

Known errors

• Uninstalling the KF SDK wipes all your Killing Floor mutators and binds. So do not.
• Selection delay is a UE2 problem caused by modern GPUs, discussed here. The selection-fix patch in the intro is the practical answer.
• Selecting surfaces specifically is even slower. Zoom in so the editor renders as little as possible.
• KF hates spaces in imported filenames. Never use them, sounds (.uax) especially.
• The config that saves build settings is broken, and editing it by hand in UnrealEd.ini breaks the editor badly. Do not.
• Static mesh limit: imported meshes above 22,000 triangles warp. See static mesh import errors.
• Modern 3DS Max and Blender 2.81+ have never successfully exported a mesh into KF1 with multiple UVs or materials — a known issue, not just bad luck.
• Broken build or terrain menus: solution thread.
• If you send a map for testing that uses workshop or modded resources without including them, the map will not appear in the tester’s list at all. Have someone open the map file in the SDK — it produces a detailed report of which resources are missing.
• If a map does not appear in the Killing Floor map list, the usual cause is a disallowed character in the name (a ., for instance) or a missing KF/KFO prefix. Missing dependencies do it too, so watch the log live while opening the file in the SDK.
• Undo (Ctrl+Z) is restricted and can crash the editor when reverting projector movements. Save often if you use it anyway.
• Projector textures multiply their alpha by roughly 1–10% on every build, so they slowly fade to fully transparent. There is no fix beyond staying aware; checking their position and scale in game is often the only reliable way.
• Animated decorations sometimes work, even on servers, and sometimes stop players loading the map entirely (and crash the SDK). There is likely a missing dependency somewhere — KF-Foundry uses them fine.
• Scale map / brush operations crash the SDK. Use the vertex editor.
• Grid alignment breaks if you consistently use BSP dimensions that are not powers of two, sizes above 1000 especially, and even more so when switching between grid 1 and 2 while something is still selected. Brushes then land between grid lines or gain phantom width in the orthographic views. If you use grid 1 for meshes, make it a religious habit to deselect before switching back to grid 2+.
• Delay time cannot be edited properly on KFDoorMovers. Fall Trigger Pack’s DoorMoverPlus does not appear to fix it.
• Ordinary movers, and the routes they travel, can break specimen pathing. KFDoorMovers do not, most likely because path collision is enabled in Properties → Collision by default — so if you insist on large movers, set that to False.
• There is a hard limit on the effective number of portals and path navigation points.
• Switching the SDK to another language (Russian, for example) breaks UI booleans such as True/False in the properties window. It may only affect installs that switch after download; either way, good luck.
• The workshop reportedly has a 100 MB upload limit. Your map should not be approaching that, and most people distribute manual download links anyway.
• The SDK can run you out of virtual memory. Hit save before dismissing the pop-up, because it auto-crashes afterwards. Toggling visibility with the hotkeys and lowering graphics settings both reduce how often it happens.

Workshop release

Tools → Upload files to Steam Workshop.

Since everyone has the same Killing Floor directory layout, the workshop uploads whatever sits inside your Killing Floor folder and installs it into other players’ folders in exactly the same place. Which means: if you left a .rom file in the Textures folder, that is where it lands on their machine too.

Tip: the description box in the upload dialog has a strict character limit. Once the item exists, you can edit the description freely on the workshop page and format it however you like.

Tags

If you tick every tag for something simple, you are part of the problem. Tags exist to make the workshop navigable; nobody moderates false ones, so nobody browses by tag, and over-tagging will not help your views either.

Reference: Tripwire wiki — Killing Floor Steam Workshop.

There is also a video of a full KF map release, covering what to consider before and after publishing.

Description template

Formatting is the main advertisement your map gets. Borrow this template or the version below (credit: NikC-):

[h1][b]General Information[/b][/h1]
This remake fixes some nasty original map [b][i]features[/i][/b].
[spoiler]for more info spam comments section[/spoiler]
[list]
[*] Patriarch's spawn in tested, delayed intervals (usually as pairs).
[*] Built-in voteable Hard Mode.
[*] Amounts of dosh given feels more balanced.
[*] There's a second level, with planks, cover and all your wildest dreams.
[*] Additional armour and high tier weapon pickups (with consistent spawn % for all difficulties).
[*] Scripted pipe bombs near blocked off Patty spawns.
[*] Addressed zed pathing issues.
[*] And more fun additions such as a replacement for the siren wave.
[/list]

[h1][b]Whitelist Status[/b][/h1]
[list]
[*] Dedicated server: all clients will level up, get achievs.
[*] Listened server: all clients will level up, get achievs.
[*] Solo: (and you guessed it) Still whitelisted.
[/list]

[h1][b]Technical Information[/b][/h1]
1. This is simply a map, no embedded mutators or whatever. To edit/remove pipe bombs
   search for the tag "PipeSpawner" in the actor class browser and delete, or navigate
   to the scripted triggers -> AI Script.
2. 'SkipWave' event command will skip to next trader (but use at own risk on normal mode).
3. The optional Hard Mode features pat spawns without timed intervals.
4. Pat spawns are storymap style, so if the probability works out you could have all of
   the patriarchs spawn in the same room.

[h3][b]Game Mode[/b][/h3]
[code]
Objective
[/code]

[h3][b]Download Link[/b][/h3]
https://example.com/your-mirror

[h3][b]Credits[/b][/h3]
Pathing, debugging - [url=steamcommunity.com/id/NikC-]NikC-[/url]

The result looks like this workshop page.

Glossary

Active brush — the red brush frame used to create new BSP or volumes. Officially the builder brush.

Brush — the building block, or blueprint, behind all BSP in your map.

BSP — binary space partitioning. Either carves out space for the player or adds solid geometry.

Icon — the smaller buttons around the top and bottom of the viewports.

Keyframe — a position or rotation set on a mover to define a step in its path, e.g. Key 0, Key 1.

LOS — line of sight.

Navigation point — anything acting as a path node for zeds and bots.

Proscribed path — a route from navigation point A to B that has been explicitly disallowed.

SM — static mesh.

ST — scripted trigger. Also, confusingly, the Siren Torturers community.

.t3d — text-based format for exporting and importing geometry and actors between map editors.

Tool — the large icons down the left side of the SDK that change what your mouse clicks do, or the shape and function of the active brush.

UE — Unreal Editor, or Unreal Engine.

.upk — Unreal’s package format holding game assets. Only relevant when porting to UE3.

Viewport — the windows you view the map through: top, front, side and 3D.

ZVol — ZombieVolume actor, used for specimen spawns.

References

Official documentation and engine info

Mapping guides and techniques

Actors and components

Videos and community

Update history of the original guide

Kept for reference, since it shows which sections the author reworked and when.

• 02/21 — Terrain section added.
• 07/23 — Tip 16, Super Tip 2, small addition to Objective Mode.
• 01/24 — KFMusicTrigger note added to Triggers; the 4 GB SDK tip copied into the Intro because too many people missed it.
• 03/24 — the BSP hole part of Build and BSP was badly outdated and got largely rewritten. Spawn Points section created. Visual reminder added to Vertex Editing. Super Tips expanded thanks to Broski. New honourable mentions in BSP and Lighting. Images previously hosted only on Imgur re-uploaded (Objective Mode and Basics on Browsers especially). Release template added to Workshop Release. Tips 5, 6 and 18 added, texture browser tip added, Errors cleaned up. Level Design edited. Link added to Known Errors for corrupt terrain and build menus.
• 04/24 — Objective Mode updated. “Hiccup” added to SkyZoneInfo. BSP hole section rewritten again. TriggeredCondition actor added to Scripted Triggers after it finally worked on a live project.
• 05/24 — large addition to Porting Maps to UE3 including video. Tips and Super Tips merged to shrink Steam’s floating table of contents.
• 10/24 — first two paragraphs of Level Design updated; Steam discussion about Unreal unit scale attached to Build and BSP.
• 12/24 — Deep Dive: Assets updated after more 3DS Max wrangling.
• 01/25 — SDK reference thread and a weather effects tutorial added to References.
• 07/25 — “Important Bonus Jank” added to Optimisation (the double framerate trick, credit jk); ammo pickup workaround added to Level Design (credit braindawg).
• 09/25 — jk’s guide attached to the Intro, since it covers the RAM patch for KFEd.exe.

Credits

The original guide is by Holy Username Batman! and is still maintained on Steam — KF SDK Tips & Mapper’s guide, with an mdBook mirror that carries the longer sections Steam’s character limit would not fit.