steam-vdf-parser

A blazing fast, zero-copy parser for Steam's VDF (Valve Data Format) files in Rust.

Supports both text and binary formats used by Steam, including shortcuts.vdf, appinfo.vdf, and packageinfo.vdf.

Features

• no_std compatible — works without the standard library, requires only alloc
• Zero-copy parsing — text format returns borrowed strings when possible (no escape sequences)
• Binary format support — parses all Steam binary VDF variants
• Version-aware — handles appinfo.vdf v40 (null-terminated keys) and v41 (string table)
• serde-free — simple, direct data structures with no hidden allocations

Usage

Text Format

use steam_vdf_parser::parse_text;

let input = r#""root"
{
    "key" "value"
    "nested"
    {
        "subkey" "subvalue"
    }
}"#;

let vdf = parse_text(input)?;
assert_eq!(vdf.key(), "root");

// Access nested values
let obj = vdf.as_obj().unwrap();
let value = obj.get("key").and_then(|v| v.as_str()).unwrap();
assert_eq!(value, "value");

// Path-based access
let subvalue = vdf.get_str(&["nested", "subkey"]).unwrap();
assert_eq!(subvalue, "subvalue");

Binary Format (auto-detect)

use steam_vdf_parser::parse_binary;

let data = read_vdf_data_somehow()?;
let vdf = parse_binary(&data)?;

// For data that needs to outlive the input:
let owned = vdf.into_owned();

Specific Formats

use steam_vdf_parser::{parse_appinfo, parse_packageinfo};

// appinfo.vdf (auto-detects v40/v41)
let data = read_vdf_data_somehow()?;
let vdf = parse_appinfo(&data)?;

// packageinfo.vdf
let data = read_vdf_data_somehow()?;
let vdf = parse_packageinfo(&data)?;

no_std Support

This library is no_std compatible and only requires the alloc crate. Enable it in your Cargo.toml:

[dependencies]
steam-vdf-parser = "0.1"

For no_std environments, make sure to have a global allocator configured:

extern crate alloc;
use steam_vdf_parser::parse_text;

// Your parsing code here

Data Structures

Vdf<'text>

The top-level VDF document. A VDF document is essentially a single key-value pair at the root level.

let vdf = parse_text(input)?;

// Access root key and value
let key: &str = vdf.key();
let value: &Value = vdf.value();

// Check if root is an object
if vdf.is_obj() {
    let obj = vdf.as_obj().unwrap();
}

// Direct nested access
let nested = vdf.get("key");  // Option<&Value>

// Path-based traversal
let deep = vdf.get_path(&["nested", "deep", "value"]);
let name = vdf.get_str(&["config", "name"]);
let count = vdf.get_i32(&["settings", "count"]);

Value<'text> Enum

Path-based access methods are also available on Value:

// Traverse nested objects
let deep = value.get_path(&["nested", "key"]);

// Typed path access
let name = value.get_str(&["config", "name"]);
let obj = value.get_obj(&["settings"]);
let count = value.get_i32(&["stats", "count"]);
let id = value.get_u64(&["user", "id"]);
let ratio = value.get_float(&["metrics", "ratio"]);

Obj<'text>

A HashMap-backed object (using hashbrown for no_std compatibility) with O(1) lookup:

let obj = vdf.as_obj().unwrap();

// Basic access
let len = obj.len();
let is_empty = obj.is_empty();
let value = obj.get("key");           // Option<&Value>
let exists = obj.contains_key("key"); // bool

// Iteration
for (key, value) in obj.iter() {
    println!("{}: {}", key, value);
}
for key in obj.keys() {
    println!("Key: {}", key);
}
for value in obj.values() {
    println!("Value: {}", value);
}

// Mutation
let mut obj = Obj::new();
obj.insert("key", Value::Str("value".into()));
obj.get_mut("key");  // Option<&mut Value>
obj.remove("key");   // Option<Value>

Lifetime and Ownership

Parsing functions return Vdf<'_> with strings borrowed from input where possible. Use .into_owned() to convert to Vdf<'static>:

let borrowed: Vdf<'_> = parse_text(input)?;
let owned: Vdf<'static> = borrowed.into_owned();

Binary Format Reference

Type Bytes

All binary VDF formats use type byte prefixes:

Entry Format

[TypeByte] [Key] [Value...]

• Key encoding varies by format (null-terminated or string table index)
• String values are always inline null-terminated UTF-8 (never from string table)

shortcuts.vdf

Simple binary format. Keys are null-terminated UTF-8 strings. Ends at EOF.

appinfo.vdf

File Header

App Entry Header (68 bytes)

VDF data starts at offset 0x44 (68 bytes). Length = Size - 60.

Key Encoding

• v40: Keys are null-terminated UTF-8 strings
• v41: Keys are u32 indices into the string table
• All versions: String values are always inline null-terminated UTF-8

String Table (v41 only)

Located at String Table Offset:

packageinfo.vdf

File Header

Package Entry Header

Followed by binary VDF blob (null-terminated keys, like shortcuts.vdf).

Performance

Text parsing is zero-copy when strings contain no escape sequences — Cow::Borrowed refers directly into the input. Escape sequences and wide strings (UTF-16) cause allocation (Cow::Owned).

Binary parsing is also zero-copy for string values. In appinfo v41, root keys (app IDs) are owned due to integer-to-string conversion, but nested values remain borrowed from the string table or input buffer.

License

Licensed under either of:

• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.