Source Engine Resources Viewer, usually shortened to SERV, is a fan-made Windows tool suite for viewing, inspecting, browsing, and launching different kinds of Source Engine resource files.
SERV is designed for people who work with, study, organize, test, or inspect files from Source Engine games and Source-based projects. It brings a collection of separate resource tools together under one native Hub, while still keeping each viewer and inspector as its own standalone program.
SERV is a fan-made utility suite. It is not affiliated with Valve, Steam, or any official Source Engine development team.
Current public build: SERV Beta 2
Build direction: Full native C++ / Qt recode
Release type: Beta / public test release
Platform: Windows
SERV Beta 2 is a major rewrite of the older Python-based SERV tool suite. The new version uses native C++ applications, Qt-based interfaces, and dedicated DLL backends for many tools.
This release is meant to be the new foundation for SERV going forward.
Use this if you want SERV installed like a normal Windows program.
Download SERV Beta 2 Setup:
Use this if you want to extract SERV into a folder and run it without installing.
Download SERV Beta 2 Portable:
https://github.com/sonicFanTech/SourceEngineResourcesViewer/releases/download/B2/SERV_PB2.7z
SERV is a collection of Source Engine resource utilities. Instead of having one giant program trying to do everything, SERV is built as a hub with many separate tools.
The Hub is used to organize, detect, launch, and manage tools. The viewers and inspectors are separate executables inside the Tools folder.
This makes SERV easier to maintain because each tool can be updated, replaced, fixed, or expanded without needing to rebuild the entire suite.
SERV can be used for things like:
- Browsing Source Engine archives.
- Inspecting map, model, texture, material, script, sound, scene, and resource files.
- Viewing metadata from Source Engine formats.
- Previewing supported assets.
- Extracting readable references from binary files.
- Building launch options for Source games.
- Playing or inspecting Source demo files.
- Organizing Source Engine research and development utilities in one place.
SERV is especially useful for modders, Source Engine fans, tool developers, archive explorers, and people who want a cleaner way to inspect Source Engine game files.
Beta 2 is not just a small update. It is a large recode of SERV into native C++ tools.
The older Python version helped prove the idea of SERV, but the new C++ version is meant to be faster, cleaner, more stable, and easier to expand.
- Rebuild the SERV Hub in C++.
- Rebuild most old Python tools as C++ tools.
- Use a cleaner
Toolsfolder layout. - Use metadata files so the Hub can detect tools automatically.
- Move format-specific logic into DLLs.
- Keep the tool EXEs focused mostly on UI.
- Make each tool easier to update without breaking the rest of SERV.
- Improve long-term performance and maintainability.
- The Hub is now a native C++ / Qt application.
- Tools are now native C++ / Qt applications.
- Many tools have their own custom management DLLs.
- Tool detection is handled through
tool.servtool.json. - The folder structure is cleaner.
- Tools are grouped into Viewers, Inspectors, and Other utilities.
- Most old tools have been remade.
- Some tools are still early prototypes and will continue improving over time.
SERV Beta 2 is working, but it is still a beta.
Some tools are more complete than others. Some tools are currently inspectors rather than full viewers. Some advanced features, like full Source model rendering or demo playback handling, may still need more work.
Known Beta 2 notes:
- MDL Viewer / Inspector can inspect models and attempt real mesh rendering, but full Source model rendering and texture resolving are still experimental.
- DEMO Player / Inspector can inspect demos and launch a Source game with
playdemo, but playback behavior depends on the game, demo location, and Source branch. - PCF Inspector currently focuses on extracting readable particle-related strings and references. Full binary PCF/DMX parsing is planned for later.
- SAV Inspector is a general binary/save inspector and may not fully decode every game’s save format.
- SWATCH Inspector and EXE/DLL Inspector are not remade in C++ yet.
SERV Beta 2 currently includes the following major tools:
| Tool | Type | Status | Purpose |
|---|---|---|---|
| SERV Hub | Hub | Working | Launches and organizes all SERV tools |
| VPK Browser | Viewer | Working | Opens and browses Valve VPK archive files |
| VTF Viewer | Viewer | Working | Opens and previews Valve Texture Format files |
| VMT Viewer | Viewer / Inspector | Working | Opens and parses Valve material files |
| Source BSP Explorer | Viewer | Working / Beta | Views and inspects Source BSP map files |
| MDL Viewer / Inspector | Viewer / Inspector | Experimental | Inspects and previews Source model files |
| VMF Viewer / Inspector | Viewer / Inspector | Working | Opens and inspects Hammer VMF map source files |
| NUT Viewer / Inspector | Inspector | Working | Opens and inspects Squirrel script files |
| VCD Viewer / Inspector | Inspector | Working | Opens and inspects Source choreography scene files |
| PCF Inspector | Inspector | Working / Early | Inspects particle system files |
| SND Inspector | Inspector | Working | Inspects sound scripts and audio metadata |
| RES Inspector | Inspector | Working | Inspects Source resource/reference files |
| SAV Inspector | Inspector | Working | Inspects save/binary files and readable strings |
| Launch Options Builder | Utility | Working | Builds Source/Steam launch command options |
| DEMO Player / Inspector | Inspector / Player shell | Working / Experimental | Inspects and launches demo playback |
The SERV Hub is the main launcher and management program for SERV.
It scans the Tools folder, reads tool metadata files, checks dependencies, displays tool status, and launches selected tools.
The Hub itself does not try to parse every Source file format. Instead, it launches the correct tool for the job.
- Native C++ / Qt interface.
- Tool list with categories.
- Tool metadata support.
- Tool status checking.
- Missing dependency warnings.
- Search/filtering.
- Open selected tool folder.
- Launch selected tool.
- About and legal sections.
- Support for hidden/internal tools.
- Support for broken-tool detection.
- Designed around a clean multi-tool folder layout.
Tools are usually organized into categories like:
- Viewers
- Inspectors
- Other
- Broken
- Hidden/Internal
The Hub reads the category from each tool’s tool.servtool.json file.
Each SERV tool should include a metadata file named:
tool.servtool.json
The Hub uses this file to identify and launch the tool.
Example:
{
"id": "VTFViewer",
"name": "VTF Viewer",
"version": "0.1.0",
"category": "Viewers",
"type": "viewer",
"executable": "VTFViewer.exe",
"description": "Open, inspect, preview, and export Valve Texture Format files.",
"icon": "icon.png",
"working_dir": ".",
"args": [],
"hidden": false,
"requires": [
"VALVETEXManagement.dll"
],
"supported_files": [
".vtf"
],
"developer": "sonic Fan Tech"
}A unique internal identifier for the tool.
The display name shown in the SERV Hub.
The current tool version.
The Hub category.
Recommended categories:
Viewers
Inspectors
Other
The tool type, such as:
viewer
inspector
utility
hub
The executable file the Hub should launch.
A short explanation of what the tool does.
A list of DLLs or files that should exist beside the tool.
The Hub can use this to show missing dependency warnings.
File extensions supported by the tool.
A normal SERV Beta 2 folder may look like this:
SERV/
├─ SERV Hub.exe
├─ SERVManagement.dll
├─ Tools/
│ ├─ Viewers/
│ │ ├─ VPKBrowser/
│ │ ├─ VTFViewer/
│ │ ├─ VMTViewer/
│ │ ├─ SourceBSPExplorer/
│ │ ├─ MDLViewer/
│ │ └─ VMFViewer/
│ ├─ Inspectors/
│ │ ├─ NUTViewer/
│ │ ├─ VCDViewer/
│ │ ├─ PCFInspector/
│ │ ├─ SNDInspector/
│ │ ├─ RESInspector/
│ │ ├─ SAVInspector/
│ │ └─ DEMOPlayerInspector/
│ └─ Other/
│ └─ LaunchOptionsBuilder/
├─ legal/
├─ config/
└─ logs/
Each tool folder usually contains:
ToolName/
├─ ToolName.exe
├─ tool.servtool.json
├─ required custom DLLs
├─ Qt runtime DLLs
└─ platforms/
└─ qwindows.dll
The VPK Browser is used to open and inspect Valve VPK archives.
VPK archives are commonly used by Source Engine games to store materials, models, sounds, scripts, maps, particles, scenes, and other game content.
- Opens
.vpkfiles. - Supports
_dir.vpkstyle archive sets. - Displays folder and file structure.
- Shows file metadata where possible.
- Supports searching/filtering.
- Supports extracting selected files.
- Supports extracting visible/filtered files.
- Helps locate materials, textures, models, scripts, sounds, and maps.
- Browse Portal 2 VPK files.
- Extract a
.vmtor.vtffile for inspection. - Find model references.
- Search for scripts, scenes, or sound files.
- Extract resources needed by another SERV tool.
The VPK Browser uses:
VALVE-PK_Management.dll
This DLL handles VPK archive management and file listing logic.
The VTF Viewer opens and previews Valve Texture Format files.
VTF files are Source Engine texture files. They are often referenced by VMT material files.
- Opens
.vtffiles. - Reads VTF header information.
- Shows texture dimensions.
- Shows version information.
- Shows mipmap count.
- Shows texture format.
- Displays supported texture previews.
- Allows mipmap selection.
- Exports the current preview as PNG.
Prototype support includes common formats such as:
- DXT1
- DXT3
- DXT5
- RGBA8888
- ABGR8888
- ARGB8888
- BGRA8888
- RGB888
- BGR888
- I8
- A8
Support may improve over later builds.
The VTF Viewer uses:
VALVETEXManagement.dll
This DLL handles VTF header parsing and image decoding.
The VMT Viewer opens Valve Material Type files.
VMT files describe how Source Engine textures and materials should behave. They often point to VTF textures through keys like $basetexture.
- Opens
.vmtfiles. - Shows raw VMT text.
- Parses shader name.
- Parses material key/value pairs.
- Detects common material keys.
- Shows material details.
- Detects
$basetexture. - Detects
$bumpmap. - Detects
$surfaceprop. - Detects
$envmap. - Detects transparency-related settings.
- Attempts to find matching VTF files.
- Exports a material summary.
Common VMT keys include:
$basetexture
$bumpmap
$surfaceprop
$envmap
$translucent
$alphatest
$phong
$selfillum
The VMT Viewer uses:
VALVE-MAT_Management.dll
This DLL handles VMT parsing and material summary logic.
Source BSP Explorer is used to open, inspect, and view Source Engine BSP map files.
BSP files are compiled map files used by Source Engine games.
Exact features may depend on the current SBSPE build, but the tool is intended for:
- Opening
.bspfiles. - Viewing map information.
- Inspecting lumps.
- Inspecting entities.
- Inspecting textures/materials.
- Viewing map geometry.
- Testing or launching maps in Source games.
- Exporting or analyzing map resources.
.bsp
SBSPE is one of the larger SERV tools and may have more complex dependencies than smaller inspectors.
When adding it to SERV Hub, make sure its tool.servtool.json file points to the correct executable and required DLLs.
The MDL Viewer / Inspector opens Source Engine model files.
Source models are more complex than many other Source formats because the visible model data is split across multiple companion files.
A typical Source model may use:
model.mdl
model.vvd
model.dx90.vtx
model.dx80.vtx
model.sw.vtx
model.phy
The .mdl file contains the model header and metadata.
The .vvd file contains vertex data.
The .vtx files contain mesh/strip information.
The .phy file contains physics/collision data.
- Opens
.mdlfiles. - Reads MDL header information.
- Detects companion files.
- Shows model name.
- Shows version.
- Shows checksum.
- Shows counts such as bones, textures, body parts, hitboxes, and sequences.
- Provides an OpenGL preview panel.
- Attempts real mesh loading from VVD and VTX files.
- Falls back to a bounds/cube preview when full mesh loading fails.
- Includes a texture/material browser window.
- Exports a model summary.
The following areas are still experimental:
- Full Source model mesh assembly.
- Correct VTX strip handling.
- Texture resolving.
- VMT/VTF loading for models.
- Material preview.
- Accurate rendering across all Source branches.
The MDL Viewer uses multiple DLLs so different parts can be updated separately:
VALVE-MDL_Core.dll
VALVE-MDL_Mesh.dll
VALVE-MDL_RenderSupport.dll
VALVE-MDL_Material.dll
VALVE-MDL_Texture.dll
VALVE-MDL_VVD.dll
VALVE-MDL_VTX.dll
VALVE-MDL_PHY.dll
Source models are complicated. Splitting the backend into multiple DLLs keeps the EXE mostly focused on the GUI and OpenGL viewer, while each DLL handles a different part of model support.
The VMF Viewer / Inspector opens Hammer VMF map source files.
VMF files are text-based map source files used by Valve Hammer Editor.
- Opens
.vmffiles. - Shows raw VMF text.
- Parses VMF block structure.
- Shows VMF tree view.
- Shows selected node properties.
- Counts entities.
- Counts solids.
- Counts sides.
- Counts materials.
- Counts visgroups, cameras, and cordons.
- Lists material references.
- Lists entity classes.
- Supports text search.
- Exports a VMF summary.
- Inspect a Hammer map source file.
- Find all material references.
- Count map entities.
- Look through brush/solid information.
- Search for specific entity classes.
The VMF Viewer uses:
VALVE-VMF_Management.dll
The NUT Viewer / Inspector opens Squirrel .nut script files.
Some Source and Source-based games use Squirrel scripts for gameplay logic, scripted events, tools, or game-specific behavior.
- Opens
.nutfiles. - Shows raw script text.
- Provides simple syntax highlighting.
- Extracts function names.
- Extracts class names.
- Extracts include/require-like references.
- Detects TODO/FIXME/HACK comments.
- Shows script statistics.
- Shows a symbol tree.
- Shows a symbol table.
- Allows jumping near symbol lines.
- Exports a script summary.
The NUT Viewer uses:
VALVE-NUT_Management.dll
The VCD Viewer / Inspector opens Source choreography scene files.
VCD files are used by Source Engine games for scenes, dialogue, gestures, facial animation timing, actor events, and choreography data.
- Opens
.vcdfiles. - Shows raw VCD scene text.
- Parses actors.
- Parses channels.
- Parses events.
- Parses timing values where possible.
- Extracts referenced sounds.
- Extracts scene text/caption-like strings where possible.
- Shows a scene tree.
- Shows an event table.
- Shows a referenced sounds list.
- Supports searching.
- Exports a scene summary.
The VCD Viewer uses:
VALVE-VCD_Management.dll
The PCF Inspector inspects Source particle system files.
PCF files are often binary particle files, commonly used for effects like smoke, sparks, explosions, glows, portals, energy effects, and other visual effects.
- Opens
.pcffiles. - Extracts readable strings.
- Detects possible particle system names.
- Detects possible operators.
- Detects possible renderers.
- Detects material and texture-related strings.
- Shows string offsets.
- Shows type hints.
- Supports search/filtering.
- Exports a PCF summary.
Full PCF parsing may require deeper binary DMX-style parsing. Prototype 0.1 focuses on useful inspection and string extraction.
The PCF Inspector uses:
VALVE-PCF_Management.dll
The SND Inspector inspects Source sound script files and some audio files.
Source sound scripts define sound names and properties used by games.
- Opens Source sound script files.
- Parses sound entries.
- Shows channel.
- Shows sound level.
- Shows volume.
- Shows pitch.
- Shows wave references.
- Opens WAV files and reads RIFF/WAVE metadata.
- Performs basic MP3/ID3 detection.
- Extracts readable strings from binary files.
- Supports raw text search.
- Exports a sound summary.
The SND Inspector uses:
VALVE-SND_Management.dll
The RES Inspector opens Source resource/reference files.
RES files can contain references to materials, sounds, models, scenes, scripts, and other files.
- Opens
.resfiles. - Shows raw RES text.
- Extracts quoted key/value pairs.
- Guesses reference types.
- Groups references by category.
- Supports search/filtering.
- Shows selected entry details.
- Exports a summary.
The inspector may identify:
- Material
- Texture
- Model
- Sound
- Scene
- Particle
- Script
- UI Resource
- Other
The RES Inspector uses:
VALVE-RES_Management.dll
The SAV Inspector opens save files and unknown binary files for inspection.
Different games use different save formats, so this tool focuses on metadata, readable strings, references, and hex preview rather than full game-specific decoding.
- Opens
.sav,.dat,.bin, and unknown binary files. - Shows file/header metadata.
- Detects save-like headers where possible.
- Extracts readable ASCII strings.
- Detects probable embedded paths/references.
- Shows reference type guesses.
- Shows hex preview.
- Supports string search/filtering.
- Exports a summary.
- Map
- Model
- Material/Texture
- Sound
- Steam/User data
- Save data
- Other
The SAV Inspector uses:
VALVE-SAV_Management.dll
The Launch Options Builder helps create Source and Steam launch option strings.
It is useful for testing mods, launching games with custom settings, debugging, changing display modes, or building reproducible launch commands.
- Builds Source/Steam launch option strings.
- Provides common presets.
- Supports display/window mode options.
- Supports developer/debug options.
- Supports insecure/mod testing options.
- Allows selecting a game EXE.
- Allows selecting a game folder.
- Allows enabling/disabling options in a table.
- Allows editing option values.
- Allows adding custom launch options.
- Shows a live command-line preview.
- Copies command line to clipboard.
- Exports a launch summary.
- Includes basic profile save/load placeholder.
- Shows warnings for conflicting, legacy, or risky options.
The Launch Options Builder uses:
VALVE-LAUNCH_Management.dll
The DEMO Player / Inspector opens Source demo files and can help launch demo playback in a Source game.
Source demo files usually use the .dem extension.
- Opens
.demfiles. - Reads Source demo header fields where possible.
- Shows map name.
- Shows game directory.
- Shows server name.
- Shows client name.
- Shows demo protocol.
- Shows network protocol.
- Shows tick count.
- Shows frame count.
- Shows playback time.
- Shows signon length.
- Extracts readable strings from binary demo data.
- Guesses referenced maps, sounds, models, materials/textures, and console/CVar strings.
- Shows a hex preview.
- Exports a summary.
- Select Source game EXE.
- Select working directory.
- Select game/mod folder.
- Add extra launch arguments.
- Toggle common launch options.
- Build a
+playdemocommand. - Copy launch command.
- Play selected demo.
- Manage demo playlists in a separate window.
- Save/load playlist files.
Demo playback depends on the game and Source branch.
Some Source games do not like absolute paths passed to playdemo. The DEMO tool may copy the selected demo to the game/mod folder and launch playback by demo name instead.
Example command style:
-game "portal2" -console -novid +playdemo "demo"
If a demo does not play:
- Make sure the demo is from the same game.
- Make sure the correct game EXE is selected.
- Make sure the working directory is correct.
- Try copying the
.demfile into the game folder. - Try launching the game manually and running
playdemo demoname. - Check the game console for errors.
The DEMO Player / Inspector uses:
VALVE-DEMO_Management.dll
Most of the old SERV tool list has now been remade in C++.
The remaining tools not yet remade are:
SWATCH Inspector
EXE/DLL Inspector
These may be added in a future SERV update.
- Open SERV Hub.
- Launch VPK Browser.
- Open a game
_dir.vpk. - Search for a
.vtffile. - Extract the
.vtf. - Launch VTF Viewer.
- Open the extracted texture.
- Export a PNG if needed.
- Launch VMT Viewer.
- Open a
.vmtfile. - Check the shader name.
- Check
$basetexture. - Use VTF Viewer to inspect the matching texture.
- Launch MDL Viewer / Inspector.
- Open a
.mdlfile. - Make sure matching
.vvd,.vtx, and.phyfiles are nearby. - Check model counts and companion file status.
- Use the preview panel.
- Open the texture/material browser if needed.
- Launch VMF Viewer / Inspector.
- Open a
.vmffile. - Browse the tree.
- Check entity classes.
- Check material references.
- Export a summary if needed.
- Launch Launch Options Builder.
- Select the game EXE.
- Select the game folder.
- Enable desired options.
- Add custom options if needed.
- Copy the generated command.
- Launch DEMO Player / Inspector.
- Open a
.demfile. - Open the Playback window.
- Select the correct game EXE.
- Select the correct working directory and game/mod folder.
- Click play.
- Check the Source console if playback does not begin.
Check that the tool folder contains:
tool.servtool.json
Also check that:
- The JSON file is valid.
- There is no trailing comma.
- The
executablevalue matches the EXE name. - The category is correct.
hiddenis not set totrue.- The file is inside a scanned
Toolsfolder.
Make sure the required DLLs listed in tool.servtool.json are next to the tool EXE.
Example:
VTFViewer.exe
VALVETEXManagement.dll
Make sure the Qt runtime files are present.
Common required files include:
Qt6Core.dll
Qt6Gui.dll
Qt6Widgets.dll
platforms/qwindows.dll
OpenGL-based tools may also need:
Qt6OpenGL.dll
Qt6OpenGLWidgets.dll
That means the MDL header loaded, but the full mesh could not be assembled.
Check for companion files:
.mdl
.vvd
.dx90.vtx
.phy
The MDL renderer is still experimental.
Make sure the related material and texture files are available.
Typical layout:
materials/models/.../texture.vmt
materials/models/.../texture.vtf
Texture resolving is still experimental and may not work for every model yet.
Try:
- Selecting the correct game EXE.
- Selecting the correct game folder.
- Selecting the correct
-gamefolder. - Copying the demo into the game folder.
- Running
playdemo demonamemanually in the game console. - Checking if the demo was recorded in the same game and game version.
SERV is a fan-made tool suite.
SERV is not affiliated with Valve, Steam, or any official Source Engine development team.
Some included or optional third-party tools may have their own licenses, permissions, or redistribution notes. Check the legal folder and any included third-party documentation for details.
Valve, Source, Steam, Half-Life, Portal, Team Fortress, Counter-Strike, and related names are property of their respective owners.
SERV is a closed-source project.
This repository and release page are for public downloads, documentation, release notes, and issue tracking where applicable.
Source code, build instructions, and compile instructions are intentionally not included.
SERV Beta 2 is a major milestone for the project.
It is now a native C++ / Qt tool suite with a rewritten Hub and many remade tools. Some tools are still prototype-level, but the suite is functional and ready for wider beta testing.
Future updates may focus on:
- Improving MDL mesh rendering.
- Improving MDL texture resolving.
- Improving DEM playback and playlist behavior.
- Adding SWATCH Inspector.
- Adding EXE/DLL Inspector.
- Improving VPK extraction workflows.
- Improving Hub tool icons and dependency checking.
- Reducing warnings and improving DLL interfaces.
- Adding more documentation and examples.
- Improving installer and portable deployment.
Developed by sonic Fan Tech.
SERV exists because Source Engine files are interesting, useful, and fun to explore.