[UX Assessment] UX Assessment: Rust (Survival Game)

[github-actions]

Related to: #24
Tracker ID: analysis-issue-24-rust

Overall Friction Rating: HIGH

Summary

Integrating Rust telemetry into GamesDAT presents significant user experience challenges. Unlike games with official telemetry APIs, Rust requires either demo file parsing (limited data, server-dependent) or memory reading (blocked by aggressive anti-cheat). The game's strict EAC implementation with hardware bans makes any third-party data access risky for end users. Setup would be complex, error-prone, and potentially violate anti-cheat policies, making this integration impractical for typical users.

Authentication Complexity

Rating: Low (for what exists)

Rust does not provide an official telemetry API or authentication system for accessing player data. The available data access methods are:

1. Demo Files (.dem): No authentication required, but only work in specific scenarios
2. Server RCON/Plugins: Requires server admin access (not applicable for typical players)
3. Memory Reading: No authentication, but blocked by anti-cheat

While there's no authentication complexity per se, the lack of official API is itself a major barrier. Users cannot simply enable a setting or get an API key—they must work around the absence of official support.

Setup Steps

For Demo File Approach (Most Viable Option)

1. Launch Rust and join a server
2. Open console (F1 key)
3. Type record (demoname) to start recording
4. Play the game
5. Stop recording when done
6. Navigate to C:\Program Files (x86)\Steam\steamapps\common\Rust\demos
7. Locate the .dem file
8. Configure GamesDAT to watch the demos folder
9. GamesDAT would need to parse the proprietary .dem format

Estimated setup time: 10-15 minutes (assuming GamesDAT implementation exists)
Technical skill required: Intermediate

Critical Limitations of Demo Approach

• No automatic recording: Users must manually type record command before each session
• Server-dependent: Full server demos exist but "don't currently have a player meaning you cannot playback these demos yet" (per Facepunch wiki)
• Post-hoc only: Demos are recordings for playback, not real-time telemetry
• Unknown format: Rust's .dem format is proprietary; no public parser exists (unlike CS2, TF2)
• File management burden: Users must manually manage demo files (can quickly fill disk space)

For Memory Reading Approach (NOT VIABLE)

1. Install GamesDAT with Rust integration
2. Launch Rust via RustClient.exe (EAC disabled) instead of normal executable
3. Connect only to EAC-unsecure servers (which don't show in server browser)
4. GamesDAT reads game memory for telemetry

This approach is NOT RECOMMENDED because:

• Connecting to unsecure servers means no official/populated servers
• The Rust community views memory reading tools as cheating
• High risk of triggering anti-cheat detection

Platform Constraints

Critical Constraint: Anti-Cheat System

Easy Anti-Cheat (EAC) with Hardware Bans

• Rust uses EAC with aggressive detection
• EAC bans include hardware (HWID) bans that affect all Rust accounts on the same motherboard/drive
• Facepunch is "serious about anti-cheat" (per 2026 statements) and explicitly rejects Linux/Proton support due to anti-cheat concerns
• In 2026, Facepunch is introducing a new third-party anti-cheat layer alongside EAC
• Simply having macro software or background apps can trigger EAC flags

Risk Assessment: Any memory-reading telemetry tool could be flagged as a cheat. The consequences (hardware ban) are severe and permanent.

Game State Requirements

• Must be actively playing: Telemetry would only work during gameplay
• Server-dependent: Can only record on servers where you're playing
• No offline/practice mode: Rust is online-only (excluding EAC-disabled unsecure servers)

Platform Support

• Windows only: Facepunch has "no plans" for Linux support due to anti-cheat concerns
• Steam version: Primary distribution platform
• No console versions: PC-only game

Ongoing Maintenance

Maintenance burden: High

Demo File Management

If using the demo file approach:

• Manual recording: Users must remember to type record (name) before each session
• Disk space: Demo files can accumulate quickly (no auto-cleanup mentioned)
• File organization: Users need to manually organize/delete old demos
• No naming automation: Must manually specify demo names each time

Game Update Risks

• Breaking changes: Demo format could change with game updates (Facepunch has no documented versioning for .dem files)
• Anti-cheat updates: The new 2026 anti-cheat layer could flag previously-safe tools
• No backwards compatibility: Facepunch documentation shows demo features are still being developed/fixed ("fix server side demos" in feedback tracker)

Parser Maintenance

• Proprietary format: Unlike CS2/TF2 which have community parsers, Rust's .dem format is undocumented
• Reverse engineering required: GamesDAT would need to reverse-engineer and maintain the parser
• No community resources: Search results show parsers for TF2/CS2 demos, but nothing for Rust
• Format changes: Facepunch could change the format without notice

Potential Deal-Breakers

1. Anti-Cheat Hardware Ban Risk

The most critical issue: Any telemetry approach that involves memory reading or process hooking could trigger EAC, resulting in:

• Permanent account ban
• Hardware (HWID) ban affecting all Rust accounts on that PC
• No appeal process for EAC bans

User Impact: Users would reasonably fear that installing GamesDAT could permanently ban them from Rust. This risk is unacceptable for typical gamers.

2. No Official Telemetry API

Unlike most games in GamesDAT's portfolio:

• F1 games: Official UDP telemetry API
• Trackmania: Official shared memory interface (ManiaPlanet_Telemetry)
• War Thunder: Official HTTP API (localhost:8111)
• Assetto Corsa: Official shared memory interface

Rust has none of these. Facepunch provides demo recording for replay/cinematic purposes, not for telemetry analysis.

3. Manual Recording Workflow

Users must manually:

• Open console before each session
• Type record (name) command
• Remember to stop recording
• Manage demo files

This is far more friction than "launch game, GamesDAT automatically captures data" which users expect based on other integrations.

4. Limited Data Availability

Demo files capture:

• Player movements and actions
• Steam IDs of players in the demo
• Timestamp information
• Gameplay recording for visual playback

They likely do not capture detailed statistics like:

• Health/hunger/temperature values
• Inventory contents
• Resources gathered
• Building data
• Detailed combat metrics

The demos are designed for visual replay, not statistical analysis. The actual structure is undocumented.

5. No Real-Time Telemetry

Demo files are post-hoc recordings. Users cannot:

• See live stats during gameplay
• Use GamesDAT for real-time dashboards
• Get immediate feedback on performance

This contradicts the value proposition of other GamesDAT integrations which offer real-time capture.

Data Access Method Analysis

Method: Demo File Parsing (Post-Game Replay Files)
UX Impact: High Friction

How It Would Work

1. User manually records demo during gameplay using console command
2. Demo file (.dem) saved to Rust/demos/ folder
3. GamesDAT watches folder for new .dem files
4. GamesDAT parses proprietary binary format to extract data
5. Data presented to user after the session

Why This Is Problematic

Compared to successful GamesDAT integrations:

Feature	Trackmania	War Thunder	F1 Games	Rust
Official API	✅ Shared memory	✅ HTTP API	✅ UDP telemetry	❌ None
Real-time data	✅ Yes	✅ Yes	✅ Yes	❌ Post-hoc only
Automatic capture	✅ Launch game	✅ Launch game	✅ Launch game	❌ Manual command
Documented format	✅ TMTelemetry spec	✅ REST API docs	✅ Packet specs	❌ Proprietary
Anti-cheat safe	✅ Built-in API	✅ Built-in API	✅ Built-in API	⚠️ No guarantees

Alternative: Server-Side Plugins (Not Applicable)

uMod/Oxide plugins can track statistics on Rust servers, but:

• Requires being a server administrator
• Not applicable for regular players joining public servers
• Data stays on the server (not accessible to players)
• Only works on modded servers (many players prefer vanilla)

This approach doesn't solve the end-user use case.

Recommendations

If Implementing Despite Challenges

1. Start with demo file approach only

   • Explicitly warn users about anti-cheat risks of memory reading
   • Document that hardware bans are possible
   • Never implement memory reading features

2. Provide clear user instructions

   • Step-by-step guide for recording demos
   • Auto-hotkey script to bind record command to a key
   • Automatic demo file cleanup tools
   • File size warnings

3. Set proper expectations

   • Clearly label as "experimental" or "limited"
   • Document data limitations
   • Explain post-hoc nature (no real-time)
   • Warn about manual workflow

4. Reverse engineer demo format carefully

   • Create test demos with known data
   • Document format versioning
   • Implement format validation
   • Plan for format changes with game updates

5. Provide user-friendly error messages

   • "Did you remember to record a demo? Press F1 and type: record (name)"
   • "Demo format version mismatch—game may have updated"
   • "No demo files found in Rust/demos folder"

Alternative Approach: Wait for Official API

The best recommendation is to wait for Facepunch to provide official telemetry support. Given:

• Rust's large player base (161,000 concurrent players)
• Growing interest in stats/analytics in gaming
• Other survival games adding telemetry features

It may be worth reaching out to Facepunch to request an official telemetry API, similar to what other competitive games provide. This would eliminate all the friction and risk.

Community Engagement

Before implementing:

1. Survey Rust community on forums/Reddit about interest in telemetry tools
2. Clarify with Facepunch whether demo parsing tools are acceptable under ToS
3. Contact EAC team to confirm read-only memory scanning status
4. Study community tools like Rustadmin to see what's already accepted

Additional Notes

Existing Third-Party Tools

The research shows several existing tools:

• BattleMetrics: Tracks server statistics (not individual player telemetry)
• RustStats.io: Leaderboards based on server data aggregation
• Rustadmin: Server-side RCON tool with REST API for stats

Key observation: All successful third-party tools operate at the server level, not client level. This suggests the community has learned that client-side data access is too risky with EAC.

Rust's Anti-Cheat Philosophy

From the research, Facepunch's position is clear:

"Rust developer has 'no plans' for Linux or Proton support, says games that support them are 'not serious about anti-cheat'"

This quote reveals Facepunch prioritizes anti-cheat above all else, even excluding entire platforms. They are unlikely to be sympathetic to third-party tools that read game memory or files, even for legitimate purposes.

Demo System Development Status

The Facepunch wiki shows the demo system is still being refined:

• Server demos exist but "don't currently have a player"
• Community feedback requests for "fix server side demos"
• Recent additions of "shots" and camera controls for cinematic use

This suggests demos are designed for content creation (YouTube videos, cinematic shots) rather than data analysis. The format may not even contain the statistical data GamesDAT would need.

Comparison to Original Research

The original issue #24 rated Rust as:

• Estimated Integration Complexity: Medium
• Reasoning: "Likely requires memory reading or file-based state capture"

Updated UX Assessment: While the technical implementation might be "medium" difficulty, the end-user experience friction is HIGH due to:

• Manual workflow requirements
• Anti-cheat risks
• Limited data availability
• Lack of official support
• Post-hoc only (no real-time)

Conclusion

Rust integration into GamesDAT would face significant UX challenges that make it impractical for typical users:

✅ What could work:

• Demo file parsing (technical challenge: format is proprietary)
• Post-session analysis only
• Manual user workflow

❌ Major blockers:

• No official telemetry API
• Aggressive anti-cheat with hardware bans
• Manual recording workflow (high user burden)
• Unknown data availability in demos
• Format could break with updates
• No real-time capture
• High implementation and maintenance cost for questionable value

Recommendation: Do not implement unless Facepunch provides official telemetry support. The risk-to-reward ratio is unfavorable:

• Risk: Users fear hardware bans, manual workflow creates friction, limited data may not be useful
• Reward: Post-hoc analysis of unknown data quality from manually-recorded demos

Better alternatives exist among the other researched games that offer official APIs and lower friction (Euro Truck Simulator 2, American Truck Simulator, DCS World, Assetto Corsa).

Sources

• [Rust Stats - BattleMetrics]((www.battlemetrics.com/redacted)
• [RustStats.io - Rust Stats and Leaderboards]((ruststats.io/redacted)
• [Rust Live Player Count and Statistics]((activeplayer.io/redacted)
• [Surviving 12 Years - News — Rust]((rust.facepunch.com/redacted)
• [Understanding Rust's Anti-Cheat Mechanisms: A Deep Dive]((www.oreateai.com/redacted)
• [Launching Rust with EAC disabled (RustClient.exe) – Facepunch Studios]((support.facepunchstudios.com/redacted)
• [Rust developer has 'no plans' for Linux or Proton support, says games that support them are 'not serious about anti-cheat' | PC Gamer]((www.pcgamer.com/redacted)
• API docs for Rust servers · Issue #28 · Facepunch/webrcon
• [Websocket Rcon]((facepunch.github.io/redacted)
• [Rust+ Server - Rust Wiki]((wiki.facepunch.com/redacted)
• [Demos - Rust Wiki]((wiki.facepunch.com/redacted)
• [Recording Demo's :: Rust General Discussions]((steamcommunity.com/redacted)
• [BattleReplay - Automatically record the player's battle playback Demo]((codefling.com/redacted)
• [How To Use Demos On Your Rust Server - Pine Hosting]((pinehosting.com/redacted)
• [Player Database plugin - uMod]((umod.org/redacted)
• GitHub - FtuoilXelrash/rPop: Oxide plug-in for Rust server
• [uMod - Rust API]((umod.org/redacted)
• [Receiving player reports - Rust Wiki]((wiki.facepunch.com/redacted)

AI generated by UX Assessment Agent