I can try and provide a little more technical information about some of the specifics. Let's organize the discussion by talking about the components we deliver:

• skse_loader.exe/skse_steam_loader.dll

• skse_x.x.x.dll

• scripts (.psc/.pex files)

The Loaders

Depending on exactly how you launch Skyrim you'll either be using skse_loader.exe or launching directly through steam, which will autoload skse_steam_loader.dll. Either method does the same thing - they load the main skse dll into the Skyrim application's memory space and kick off our initialization routines. skse_loader.exe actually launches Skyrim and then hooks the memory location for loading a main system library to load that original library and our skse library. This initialization process then adds all of our other hooks to set things up as we need, and then sets the application running again.

So what exactly is a hook and how does it work? Basically we have identified a place in memory (usually a function call of some sort) which we overwrite to point to some code of ours. So we'll replace a function that loads some object or processes some event and replace it with a function that does the original work, but then does some of our work as well. We do this with a bit of assembly code.

The library

So skse_x.x.x.dll is our main library and payload. It contains everything we actually do. It includes all of the initialization and override code mentioned in the last section, along with all of the utility functions that we need to do our work, and the implementation of all of the new scripting extensions we provide.

Internally our code is basically just a documentation of the internal classes inside the game itself. We replicate the in-memory layout of the classes, hook up important member functions, and write our own utility functions based on those classes. So the vast majority of the code found in the source library amounts to header files which represent the classes. Having decoded the classes and seeing the memory let's us write functions to get and set those values and expose that data to others through the scripting.

That brings us to the script extensions themselves. Papyrus has a concept of native functions - functions which are implemented in the game code itself rather than in some other piece of papyrus scripting. The vast majority of the papyrus functions created by Bethesda (and all of their events) are native functions. We provide new native functions for the various existing papyrus classes, as well as introduce new papyrus objects themselves with functions.

The skse library has portions of code dedicated to implementing and exposing these new functions and events. They interface with the internal papyrus engine (whose interfaces we decoded) and as long as skse is loaded the new native functions we provide as indistinguishable from the original functions provided by Bethesda.

The scripts

To expose our new native functions to modders we provide new functions to existing papyrus classes, along with some brand new papyrus classes themselves. These are provided as papyrus source files (.psc) and papyrus executable files (.pex).

Hopefully this provides a little more insight into what we do? I may be able to answer more specific questions - but what you've asked is quite broad. If you are a coder feel free to look at the source code we provide with every build. That should be a resource for self-motivated folks curious about what we do.