Fougerite Official 1.9.95

**Full Changelog**: https://github.com/Notulp/Fougerite/compare/v1.9.94...v1.9.95

* Added the SteamPaidAccounts mode to SteamAuthMode. It allows Spacewar players whose ticket is verified through the Steam Web API and whose Steam account is not limited, meaning it has spent at least 5 USD on Steam. This keeps out freshly made alt accounts without requiring Rust ownership. Private profiles are fine, but the player must have set up a Steam Community profile once. Requires SteamWebAPIKey.
* Fixed genuine Spacewar tickets being rejected by the Steam Web API with "101 Invalid ticket". Fougerite now retries for about 5 seconds while Steam registers a fresh ticket. It also cuts off buffer padding some clients send after the ticket. No client changes are needed.
* Rewrote the Steam setting comments in Fougerite.cfg as a readable table, showing per mode who can join, whether an API key is needed and what the Steam profile needs. If your config still shows the old comments, delete the four Steam lines once and they will be written again on the next startup.
* The startup log now warns about the profile requirements of RustOwners and SteamPaidAccounts, so server owners aren't surprised by rejected players.
* AssetBundleLoader received a simple asset loading API. LoadAsync<T>(path, callback) waits for queued plugin bundles and the game's own bundles, then loads the asset without stalling a frame. Load<T>(path) does the same lookup instantly. LoadBundle(path, version) queues a bundle without a callback. Plugin bundles are searched first, then the game's.
* Added AssetBundleLoader.LoadAndInjectBundle and InjectWhenBundlingLoaded for plugins that keep calling Facepunch.Bundling.Load directly. They inject the bundle as soon as the game finished loading.
* Rewrote InjectIntoFacepunchBundling against the game's actual Bundling layout. It no longer relies on Util reflection, ignores duplicate injections and logs exactly what is missing if a game build differs.
* AssetBundleLoader documentation now has a code example on every public member.

Updated ranking from most safe to least safe:

1. RustOnly (Most Safe): Only native Rust (252490) players. Blocks all Spacewar, emulated and cracked clients.
2. RustOwners (High Safety): Spacewar players whose account owns Rust. Requires public game details.
3. SteamPaidAccounts (High Safety): Spacewar players on a genuine, non-limited Steam account. Rust ownership is not required.
4. SteamAccounts (Medium Safety): Spacewar players on any genuine Steam account. Most recommended with RustBuster.
5. SteamAccountsUnverified (Low Safety): Offline checks only. A well-forged ticket can spoof any SteamID.
6. Legacy (Very Low Safety): No checks of its own, plugins decide.
7. AllowAll (Zero Safety): Anyone can connect, including clients without Steam.

**Full Changelog**: https://github.com/Notulp/Fougerite/compare/v1.9.93...v1.9.94
* Added lots of AI documentations
* Updated the patcher exe, because i forgot to upload it last time
* Added Hooks.OnPlayerUnban and UnbanEvent
* Added Fougerite.cfg setting DisableFacePunchTruthPunish. It is automatically added on next startup.
* Added CustomMap class, Hooks.OnCustomMapLoaded and CustomMapLoadedEvent. This is still experimental code.
* Added AssetBundleLoader class for smooth asset loading. It also has an InjectIntoFacepunchBundling function.
* Updated SteamAPITools class, added SteamTicketValidator class, SteamDenyEvent received new properties
* Added Fougerite.cfg setting SteamAuthMode, SteamWebAPIKey, SteamWebAPITimeout, SteamWebAPIFailOpen settings. All will be added to your config next startup. The new Steam configuration settings give server owners control over how connection tickets are handled when standard Steam authentication fails (such as Spacewar 480 tickets or cracked clients). For this before, we used to use plugins like **AuthAllow, but they are no longer required**. `SteamAuthMode` sets the strictness of player access, letting you require verified Rust ownership (`RustOwners`), genuine Steam accounts (`SteamAccounts`), basic offline ticket validation (`SteamAccountsUnverified`), legacy plugin-handled checks (`Legacy`), or unrestricted access (`AllowAll`). To support the API-based modes, `SteamWebAPIKey` stores your Steam developer key, `SteamWebAPITimeout` sets how long a connecting player waits for API responses (1 to 45 seconds), and `SteamWebAPIFailOpen` determines whether players on Spacewar tickets are allowed or rejected if the Steam Web API times out or goes offline. Basically

Here is the ranking from **most safe** to **least safe**, to use Steam checks, you need to get an API key from https://steamcommunity.com/dev/apikey and set it in the config:

1. **`RustOnly` (Most Safe)** - Enforces strict native Steam authentication for Rust (252490). Completely blocks all Spacewar, emulated, or cracked clients.
2. **`RustOwners` (High Safety)** - Allows Spacewar tickets, but uses the Steam Web API to verify the account actually owns paid Rust.
3. **`SteamAccounts` (Medium Safety)** - Verifies via Web API that the Spacewar ticket belongs to a legitimate Steam account, but does not require Rust ownership. **This is the most recommended setting to use with RustBuster.**
4. **`SteamAccountsUnverified` (Low Safety)** - Performs basic offline checks to filter out sloppy emulators, bypassable by well-forged tickets spoofing any SteamID.
5. **`Legacy` (Very Low Safety)** - Performs no ticket verification on its own, delegating access decisions entirely to plugins.
6. **`AllowAll` (Zero Safety)** - Disables all checks and allows anyone to connect, including clients without Steam.

1.9.93

**Full Changelog**: https://github.com/Notulp/Fougerite/compare/v1.9.92...v1.9.93

* Added ILAudit for patching verification
* Fixed patcher bugs
* Added threaded timer check improvement by displaying caller if available
* Added a completely customizable swimming class which is disabled by default. See WaterSystemServer. Client side modification is also required to use via RustBuster to make it work.
* Made DatablockDictionary fields public for easier modding access
* Added AnimalMovementEvent.BasicWildLifeMovement and AnimalMovementEvent.Type. The hook will no longer be called only for Navmesh events, but also for actual animal movmements.
* Added OnAudibleSound hook
* Added OnWaterDamage hook
* https://github.com/Notulp/Fougerite/commit/e8a7673d5412b883ff32e7c16495e5c9b3b4c9bc

• * Improved autoupdater
  * Fixed a rare auto-reload error
  * Added new Fougerite.cfg option ServerMessageName
  * Remaining addition of the documentation in Fougerite
  * IniParser.AddDefault
  * IniParser.AddSetting now has documentation option

• Added Server.RestrictCommand
• Added Server.UnRestrictCommand
• Added Server.CleanRestrictedCommands
• Added Server.CommandCancelList
• Added Player.IsSteamUser
• Added Player.SteamUserType
• Added SteamAPITools class API for checking SteamTickets for validation
• Added SteamUserRegistry class for Steam players tracking
• Added Util.IsSteamUser(ulong steamId)
• Added Util.GetSteamUserType(ulong steamId)
• Added SteamDenyEvent.IsValidSteamUser to track if the denied player is a steam user
• Added CoroutineHost class
• Added On_PermissionChange event with PermissionEvent class
• Added auto-updater script you can run via powershell

• Added ignore case for Utils.ContainsString
• Updated librust.dll within rust_server_Data\Plugins directory
• Updated GlitchFix dll and GlitchFix cfg to their latest code

**Full Changelog**: https://github.com/Notulp/Fougerite/compare/v1.9.7...v1.9.8

* Added DataStore.Wipe
* Updated GlitchFix with lots of new features. Update your GlitchFix.cfg as well
* Plugins running code on threads using fougerite API class Logger, like Logger.Log to log information including any other functions like Error, Warning, and so on, will now be displayed on the console using our custom `librust.dll` build. No logs will be missed because running code on multiple threads.

**Full Changelog**: https://github.com/Notulp/Fougerite/compare/v1.9.6...v1.9.7
* Documented Module.cs and CSPlugin.cs
* Documented PluginWatcher
* Fixed error when doing CTRL+C for shutdown when the server is not initialized yet
* Added sanity checks to Config.cs
* Fixes in Logger.cs
## x64 Upgrade (v1.9.7+)

Starting from version **1.9.7**, Fougerite ships [Fougerite_LibRust_x64] for testing, a full x64 reimplementation of the original x86 `librust.dll`, alongside x64 builds of `rust_server.exe` and `mono.dll`.

**Delete these files from the server root**, they are x86-only Steam redistributables that do not belong in an x64 process:

- `steamclient.dll`
- `steam_api.dll`
- `tier0_s.dll`
- `vstdlib_s.dll`

**Overwrite these files** with the x64 versions from the release:

- `librust.dll`
- `rust_server.exe`
- `mono.dll`

### Why x64 on a 2013 Unity 4.5.5f Engine

- **No 4 GB memory ceiling.** x86 processes are limited to roughly 4 GB of virtual address space. x64 removes that cap entirely, meaning large maps, high player counts, and heavy plugin loads no longer risk out-of-memory crashes that previously required server restarts.
- **More CPU registers.** x64 doubles the number of general-purpose registers over x86. The Mono (Mini) JIT compiler can keep more values in registers rather than spilling to the stack, reducing memory traffic on hot paths like the game loop, plugin execution, and networking.
- **Native on modern operating systems.** Running natively x64 removes the WOW64 compatibility layer that every x86 process runs under on modern Windows, eliminating a layer of overhead on every system call.
- **Better calling convention.** The x64 calling convention passes more arguments in registers rather than on the stack, which is more efficient than the x86 stdcall/cdecl conventions used by the original server.
- **Stability.** Address space exhaustion is one of the leading causes of long-running Rust Legacy server crashes.
- **Future compatibility.** x86 tooling, runtimes, and OS support will continue to erode. The x64 build ensures Fougerite can run on whatever comes next without requiring a compatibility update hopefully for the next 20 years..

**Full Changelog**: https://github.com/Notulp/Fougerite/compare/v1.9.5...v1.9.6

* Added fougerite.load console command
* Added custom mono.dll which allows C# plugins to be properly reloaded for easier testing. Each plugin has its own appdomain.
* Fixed up fougerite.unload and fougerite.reload commands
* Added SilentConsoleCommands to Fougerite.cfg allowing to suppress console messages in F1 console for certain commands
* More Rust and Fougerite config options logged during boot
* Added Data.IsStringNullOrEmpty
* Added Data.IsStringNullOrWhiteSpace

**Full Changelog**: https://github.com/Notulp/Fougerite/compare/v1.9.4...v1.9.5

* Supplied xml files to help plugin development with visible documentation.
* Documented more code
* Code fixes
* Added buffersize to ScriptWebSocket
* Added BasePlugin.WebSockets
* Supplied PDB file
* Fougerite.Module now derives from BasePlugin with backwards compatibility. Should not cause errors but help boost the experience of C# development and now all things should be at the same place.
* ScriptWebSocket has been finalized and implemented properly
* Data class has received lots of helper functions for script plugins and docs
* Lazy type implementations where it was needed
* Rust++ updated and history command was refined
* Added World.GetAllTreeInstances()
* Initialized the never used WoodBlockerTemp class to take the responsibility of proper tree cutting to the server rather than the client. Infinite wood cutting cheats will no longer work on trees. You can also no longer farm trees without being actually close to them using a cheat.
* GatherEvent was refined, AmountLeft and PercentFull will no longer throw errors on use when cutting a Tree
* Added GatherEvent.WoodBlockerTemp
* Added GatherEvent.TreeGameObject
* Added GatherEvent.ResourceTargetType
* Added World.AllTrees which gets filled after Server initialization complete event
* Refined ConcurrentDictionary
* Refined ConcurrentList
* Refined Server.ChatHistoryUsers and Server.ChatHistoryMessages
* Added Util.ChatHistory, only 2000 messages are kept and 1000 is proned after reaching 2000.
* **Patcher updated please re-patch or use prepatched files**

## What's Changed
* Websocket test by @DreTaX in https://github.com/Notulp/Fougerite/pull/160


**Full Changelog**: https://github.com/Notulp/Fougerite/compare/v1.9.3...v1.9.4

* Added IsIntensiveEventAllowed warning
* Refactored plugin loader
* Added Plugin.CreateWebSocket for websockets
* Fixed patcher crash, RE-PATCH OR USE PREPATCHED DLLS!!
* Added On_WebSocketMessage
* Added On_WebSocketClosed
* Added On_WebSocketConnected
* Added On_WebSocketError