sfm compile: Complete Source Filmmaker Model Guide

A model can look perfect in Blender and still appear invisible, untextured, or completely broken inside Source Filmmaker. The missing piece is often the compilation pipeline that converts ordinary 3D assets into files Valve’s Source engine understands.

sfm compile is the process of preparing Source Filmmaker assets for the Source engine. For custom models, this usually involves exporting geometry and animation as SMD or DMX files, describing the model with a QC script, and running StudioMDL—often through Crowbar—to produce MDL, VVD, VTX, and optional PHY files.

The phrase is sometimes used loosely for rendering an animation, but model compilation and final video rendering are technically separate processes. This guide focuses primarily on the model and asset workflow, which is the dominant meaning found across current search results.

What Does sfm compile Mean?

Source Filmmaker, commonly shortened to SFM, is Valve’s filmmaking and animation software built around Source engine technology. Unlike Blender, Maya, or 3ds Max, Source Filmmaker cannot simply load every ordinary 3D project file directly.

A custom model must be converted into the asset structure expected by the engine.

Think of the workflow as a translation process:

3D software → Source-compatible source files → QC instructions → StudioMDL → compiled Source model → Source Filmmaker

For a typical custom character or prop, the compiler receives geometry, skeleton information, animation data, material references, and configuration instructions. It then generates a collection of binary files that Source Filmmaker can load.

That is why dropping an .fbx, .obj, or .blend file into an SFM models folder does not work.

Compilation is different from rendering

One source of confusion is that some SFM users call exporting a completed animation a “compile.”

Technically, these workflows solve different problems:

Process	Purpose	Typical Input	Typical Output
Asset compilation	Makes models usable by Source	SMD/DMX + QC	MDL, VVD, VTX, PHY
Material preparation	Makes textures usable	Image files	VTF + VMT
Animation rendering	Produces finished visuals	SFM scene	Frames or movie
Video encoding	Creates delivery format	Rendered frames/video	MP4 or another video file

A custom model therefore needs to be compiled before it can be properly used in an animation. Rendering happens after the scene, lighting, camera work, posing, and animation are finished.

Files Used in the sfm compile Workflow

The file extensions can make the Source pipeline look harder than it actually is. Once you know what each file does, troubleshooting becomes much easier.

SMD

SMD, or Studio Model Data, is a long-established Source model format used for mesh, skeleton, and animation information.

An SMD is not itself the finished model. It is source data that StudioMDL uses during compilation.

A project might contain separate files such as:

• character_reference.smd
• idle.smd
• run.smd
• physics.smd

Complex models may contain several SMD meshes. Community guidance also notes that individual mesh objects can be exported separately and assembled through QC directives such as $body, $model, or $bodygroup.

DMX

DMX is another format used in Valve’s asset pipeline.

Depending on your exporter and model requirements, you may work with SMD, DMX, or a mixture of Source-compatible files. Steam community guidance for custom SFM models commonly recommends exporting a mesh as either SMD or DMX before creating the QC and compiling it.

QC

The QC file is one of the most important parts of an SFM model compile.

It is a plain-text instruction file that tells StudioMDL how the model should be assembled.

A very simple QC might resemble:

$modelname "custom/example.mdl"

$body body "example.smd"

$cdmaterials "models/custom"

$sequence idle "example.smd"

Each instruction has a purpose.

$modelname defines where the compiled model belongs.

$body identifies a mesh.

$cdmaterials tells the model where to look for its materials.

$sequence specifies animation sequence information.

More sophisticated QC files can define bodygroups, flexes, skins, attachments, jiggle bones, LOD settings, animation sequences, and other model properties.

You do not convert an SMD into a QC. The QC is created separately as a text file containing the instructions that the compiler needs.

MDL

The .mdl file is the central compiled model file that SFM recognizes.

However, an MDL usually does not work alone. Source models commonly rely on additional generated files.

VVD

The VVD stores vertex-related data used by the compiled model.

Deleting or forgetting supporting model files can make a model fail even if its .mdl file is present.

VTX

VTX files contain optimized mesh information used for rendering.

You may see filenames containing variants such as .dx90.vtx depending on the Source branch and compile configuration.

PHY

A .phy file contains physics or collision information when the model has applicable collision data.

Not every SFM model requires one.

VTF and VMT

Models and textures follow related but separate pipelines.

The model compiler does not magically turn an ordinary PNG or JPG into a complete Source material.

Traditional Source materials generally use:

• VTF for texture data
• VMT for material configuration

Community instructions for adding custom SFM models commonly recommend converting textures to VTF and creating VMT files for the materials after compiling the model.

Tools Needed to Compile a Model for SFM

You do not need a huge software stack.

For a basic workflow, you normally need a 3D editor, an appropriate exporter, Source Filmmaker, a compiler interface, and tools for preparing Source materials.

Blender

Blender is one of the most common starting points because it can handle:

• mesh editing
• UV mapping
• rigging
• weight painting
• animation
• material preparation
• export through Source-compatible add-ons

The important step is not simply saving the Blender project. You need to export the asset into a format appropriate for the Source pipeline.

StudioMDL

StudioMDL is Valve’s Source model compiler.

It reads the QC script and associated source files, then generates the compiled model.

A useful technical distinction is that Crowbar does not replace StudioMDL itself. Crowbar provides a convenient graphical workflow and launches the appropriate compiler. This distinction has also been clarified by experienced Source Filmmaker community contributors.

Crowbar

Crowbar is widely used because it makes Source model compiling and decompiling considerably easier.

Instead of manually building command-line instructions, you can select:

1. the game configuration,
2. the QC file,
3. compilation options,
4. the compile command.

Crowbar then shows the compiler output in a readable log.

This log matters. When something fails, the useful answer is often already written there.

Text editor

A QC does not require a special programming environment.

A basic text editor can create one, although an editor with syntax visibility and line numbers can make troubleshooting more comfortable.

How to sfm compile a Custom Model Step by Step

A clean compile starts long before you press the Compile button.

1. Prepare the model in your 3D software

Start by checking the actual asset.

Before export, verify:

• model scale
• mesh orientation
• skeleton structure
• bone names
• vertex weights
• UV coordinates
• material assignments
• animation data
• object names

A compiler can package a correctly prepared model, but it cannot automatically repair bad rigging or missing UVs.

If your character looks distorted before export, compilation will not make it correct.

2. Export the mesh as SMD or DMX

Export your reference mesh using a Source-compatible workflow.

For example:

mycharacter.smd

If the character contains separate animation sequences, those may be exported separately:

idle.smd
walk.smd
run.smd

Keep filenames straightforward. Complicated directory structures and inconsistent names make QC troubleshooting unnecessarily difficult.

3. Organize your source files

A simple working directory might look like this:

mycharacter/
├── mycharacter.qc
├── mycharacter.smd
├── idle.smd
└── walk.smd

This arrangement makes relative paths easier to manage.

Relative paths are especially important in Source model work. Experienced SFM contributors generally recommend referencing source assets relative to the QC rather than filling the QC with long absolute Windows paths.

4. Create the QC file

Create a text file and save it with the .qc extension.

For a simple rigged model, a starting structure could be:

$modelname "custom/mycharacter.mdl"

$body "body" "mycharacter.smd"

$cdmaterials "models/custom/mycharacter"

$sequence "idle" "idle.smd"

Do not blindly copy a large QC from another model.

Commands that make sense for a static prop may be wrong for a rigged character, while directives designed for characters may be unnecessary for a simple object.

Treat the QC as a description of your model, not a template that must contain every possible command.

5. Configure Crowbar

Open Crowbar and move to the Compile section.

Choose Source Filmmaker as the target game configuration and select the QC you created.

The underlying compiler must be pointed at the correct Source Filmmaker environment.

Then start the compile.

Crowbar will display output produced during the process. A successful run should create the model and its required supporting files.

6. Read the compile log

Do not close the log immediately.

Look for terms such as:

ERROR
WARNING
could not load
unknown command
missing
aborted

A warning is not automatically fatal.

An error followed by aborted processing usually means the final model was not generated successfully.

The first meaningful error is often more useful than the last line. Later errors may simply be consequences of the original failure.

7. Check the generated model files

Depending on the asset, your compiled output may include:

mycharacter.mdl
mycharacter.vvd
mycharacter.dx90.vtx
mycharacter.phy

Do not copy only the MDL and forget its supporting files.

Keep the generated model files together under the correct Source Filmmaker model directory.

8. Prepare the textures

Now prepare the material side of the asset.

A traditional arrangement might be:

materials/
└── models/
    └── custom/
        └── mycharacter/
            ├── body.vtf
            └── body.vmt

The QC $cdmaterials value and actual materials directory must agree.

The mesh’s material name must also correspond with the material files it is supposed to use.

9. Load the model in Source Filmmaker

Launch SFM and open the model browser.

If the model does not immediately appear, verify:

• the correct mod is being searched,
• subfolder searching is enabled where relevant,
• the model filter is not hiding the asset,
• the compiled files are actually in the expected model directory.

Community troubleshooting guidance specifically recommends checking SFM’s model-browser mod filter and subfolder options when custom models cannot be found.

Why an SFM Model Has Purple-and-Black Textures

The purple-and-black checkerboard is one of the most recognizable Source engine errors.

It generally means the engine cannot resolve the expected material or texture.

This is primarily a material-path problem, not proof that model compilation completely failed.

Check four things.

Material name

Make sure the material assigned to your mesh matches the intended Source material.

$cdmaterials

Suppose your QC contains:

$cdmaterials "models/custom/mycharacter"

SFM will expect the corresponding materials under a matching path beneath its materials directory.

VMT file

The VMT must reference the correct texture.

A simple material might use a structure similar to:

"VertexLitGeneric"
{
    "$basetexture" "models/custom/mycharacter/body"
}

VTF file

Make sure the referenced texture actually exists.

A successful MDL compile does not guarantee correct materials. Current SFM guides consistently identify missing material references as a common reason models appear with checkerboard textures.

Quick Takeaway: If the model appears but is purple and black, investigate VMT, VTF, material names, and directory paths before rebuilding the entire mesh.

Common sfm compile Errors and How to Fix Them

Compilation becomes far easier when errors are treated as specific messages rather than random failures.

“Could not load file”

Example:

ERROR: could not load file 'mycharacter.smd'

The compiler cannot find the referenced source file.

Check:

• filename spelling
• extension
• QC path
• source directory
• relative path
• uppercase/lowercase differences where relevant

A community example shows StudioMDL aborting because the QC referenced an SMD that was not present under the expected filename.

“Aborted Processing”

This is often not the root problem.

Scroll upward in the log.

If the compiler first says it could not load an SMD and then reports that processing was aborted, fix the missing file rather than searching for an independent “aborted processing” solution.

Model compiles but does not appear

First verify the destination specified by $modelname.

For example:

$modelname "custom/mycharacter.mdl"

Then confirm that the generated files exist in the expected models path.

Also check SFM’s model-browser filters.

Model appears in a T-pose

A T-pose usually points toward rig or animation configuration rather than simply a missing MDL.

Check:

• skeleton
• animation exports
• $sequence
• bone names
• reference pose
• rig compatibility

If the model is meant to have animation but the QC never defines usable sequence data, compiling the geometry alone will not create the animation behavior you expected.

Model is distorted

Look back at the source model.

Common causes include:

• incorrect weighting
• mismatched skeleton
• bad transforms
• scale problems
• incorrect bone orientation
• export settings

Compilation packages the data it receives. It cannot determine the artistic intent behind a malformed rig.

Textures load from the wrong folder

Check $cdmaterials.

Avoid using arbitrary absolute file-system locations as material references. Source assets are generally organized around paths relative to game content directories.

Crowbar appears to do nothing

Inspect its output rather than relying only on the button state.

Confirm:

1. Source Filmmaker is selected correctly.
2. Crowbar can locate the compiler.
3. The QC is valid.
4. Referenced source files exist.
5. The destination is writable.
6. The compile log does not contain an earlier fatal error.

QC Commands Worth Understanding

You do not need to memorize the entire QC language to compile your first model, but several commands appear frequently.

QC Command	Typical Purpose
$modelname	Sets compiled model path/name
$body	Adds a model mesh
$model	Defines model information
$bodygroup	Creates selectable mesh groups
$cdmaterials	Specifies Source material path
$sequence	Defines animation sequence
$texturegroup	Defines material/skin variants
$mostlyopaque	Helps with models mixing transparency behavior
$collisionmodel	Defines collision mesh when applicable
$staticprop	Configures appropriate static-prop behavior

Do not add directives simply because another QC contains them.

For example, community guidance warns that $staticprop changes model behavior and is not something to copy casually into a rigged character’s QC.

Compiling Bodygroups, Skins, and Multiple Meshes

Once a basic model works, you can build more sophisticated features.

Bodygroups

Bodygroups allow meshes to be switched.

A character could have interchangeable parts such as:

• hat
• hair
• glasses
• jacket
• accessory

Multiple exported meshes can be assembled through the QC instead of being permanently combined in Blender.

This is especially useful when you want SFM users to toggle parts without loading separate models.

Skins

Skins allow the same mesh to reference alternate material sets.

You might use them for:

• different clothing colors
• damaged/clean variants
• alternate eye textures
• team colors
• character variations

QC texture-group definitions control how these alternatives are presented.

Flexes

Facial animation adds another layer to the pipeline.

Models that use facial expressions may require flex-related data and appropriate Source-compatible configuration. This is more involved than compiling a simple prop, so first confirm that the base mesh, skeleton, materials, and ordinary sequences work.

A good workflow is incremental:

compile simple → test → add feature → compile again → test again

That approach makes failures much easier to isolate.

Should You Decompile an Existing Model First?

Crowbar is also commonly used to decompile Source models.

Decompiling a functioning model can be educational because you can inspect its:

• QC structure
• mesh organization
• material paths
• sequences
• bodygroups
• attachments

It is particularly useful when working with your own assets or content you have permission to modify.

However, a decompiled QC should be treated as a reference, not a universal template.

A character from one Source game may contain features or assumptions that your SFM model does not need.

Recompiling someone else’s model also does not automatically grant permission to redistribute or modify it. Asset licensing and creator permissions remain separate from the technical ability to decompile a file.

Source 1 and Source 2 Are Not the Same Pipeline

Another mistake is combining tutorials for different Valve engine generations.

Traditional Source Filmmaker uses the original Source-era asset workflow commonly associated with StudioMDL, QC, SMD/DMX, MDL, VTF, and VMT.

Source 2 tools use a different resource pipeline.

That means a tutorial created for Source 2 Filmmaker or Half-Life: Alyx tools should not automatically be treated as instructions for the classic Source Filmmaker application. Current SFM compile coverage also distinguishes these workflows rather than treating them as interchangeable.

Always identify which engine and toolchain a tutorial targets before following its file instructions.

SFM Compile vs SFM Animation Export

If you searched for sfm compile because you are trying to create a finished video, you are dealing with the other common interpretation of the phrase.

A model compile makes an asset usable.

A render or export makes your finished animation viewable outside the project.

For finished animation work, many creators prefer rendering an image sequence rather than depending entirely on one direct movie file.

An image sequence has a practical advantage: if something interrupts a long render, already completed frames remain available.

The frames can then be assembled and encoded in video-editing software.

So the two pipelines can be summarized as:

Custom model:
Blender → SMD/DMX → QC → StudioMDL → MDL → SFM

and:

Finished animation:
SFM scene → rendered frames → video editor/encoder → final video

Keeping this distinction clear prevents a large amount of confusion when following tutorials.

A Reliable Troubleshooting Order

When a custom model refuses to work, changing ten settings simultaneously is rarely efficient.

Use this sequence instead:

1. Read the complete compiler log.
2. Fix the first fatal error.
3. Confirm the QC can find every SMD or DMX.
4. Confirm the compiled MDL/VVD/VTX files were created.
5. Verify the model output directory.
6. Open the model in SFM.
7. If the geometry works, troubleshoot materials separately.
8. If materials work, test skeleton and animation.
9. Add bodygroups, skins, flexes, physics, or advanced features last.

This isolates one stage of the pipeline at a time.

For example, if StudioMDL never creates an MDL, there is little value in troubleshooting a VMT yet.

If the MDL appears correctly but has checkerboard textures, recompiling the geometry repeatedly is usually a distraction.

Quick Takeaway: Divide the project into geometry, compilation, materials, rigging, and animation. Test each layer independently instead of treating “the model is broken” as one problem.

Best Practices for a Cleaner SFM Workflow

A few habits save more time than any clever compiler trick.

Keep source and compiled files separate

Maintain a working directory containing your editable QC, SMD, DMX, texture sources, and Blender files.

Treat SFM’s game directory as the destination for usable compiled assets rather than your only project archive.

Use short, predictable paths

A structure such as:

models/custom/robot/
materials/models/custom/robot/

is far easier to debug than an improvised maze of unrelated directories.

Change one thing at a time

If a model compiles successfully, create a backup before adding advanced QC features.

That gives you a known-good version to return to.

Read warnings instead of ignoring everything

Not every warning prevents a model from loading, but warnings can expose future problems.

Learn which messages are harmless in your specific model and which point to genuinely missing data.

Keep the compile log

If you need help from another SFM creator, provide the relevant QC and complete compiler log rather than describing the error only as “Crowbar doesn’t work.”

Community troubleshooting threads repeatedly rely on the compiler output to identify missing source files, incorrect paths, and malformed model instructions.

What a Successful sfm compile Looks Like

A successful pipeline should leave you with a predictable chain.

Your source model is clean.

Your mesh and animation data export correctly.

Your QC references the correct files.

StudioMDL processes them without a fatal error.

The compiled model and supporting files appear in the intended Source Filmmaker directory.

Your VMT and VTF materials resolve correctly.

Finally, SFM finds the model in its browser and loads it with the intended mesh, skeleton, materials, bodygroups, and animation sequences.

That is the core idea behind sfm compile. It is not one mysterious conversion button. It is a small asset pipeline in which Blender or another 3D package prepares the source data, the QC explains how the model should be constructed, StudioMDL performs the actual compilation, Crowbar simplifies that process, and Source Filmmaker loads the resulting Source-compatible files.

For your first model, keep the pipeline simple: export one clean mesh, write a minimal QC, compile it, verify the geometry in SFM, and only then add materials and advanced features. Once that basic cycle works reliably, bodygroups, skins, custom animations, flexes, and more complex characters become much easier to troubleshoot.