diff --git a/documentation/docs/fullsimlight/fsl/fsl-gen.png b/documentation/docs/fullsimlight/fsl/fsl-gen.png
new file mode 100644
index 0000000000000000000000000000000000000000..49aa7b5ad8b607887f1c70b58a5b26f021feeabd
Binary files /dev/null and b/documentation/docs/fullsimlight/fsl/fsl-gen.png differ
diff --git a/documentation/docs/fullsimlight/fsl/fsl-mag.png b/documentation/docs/fullsimlight/fsl/fsl-mag.png
new file mode 100644
index 0000000000000000000000000000000000000000..d79d550f462d44e12c72c13420a1ac9ee2dcbad3
Binary files /dev/null and b/documentation/docs/fullsimlight/fsl/fsl-mag.png differ
diff --git a/documentation/docs/fullsimlight/fsl/fsl-main.png b/documentation/docs/fullsimlight/fsl/fsl-main.png
new file mode 100644
index 0000000000000000000000000000000000000000..a37c81e7fdd369b685e3c70e2d580ebe27627de3
Binary files /dev/null and b/documentation/docs/fullsimlight/fsl/fsl-main.png differ
diff --git a/documentation/docs/fullsimlight/fsl/fsl-reg.png b/documentation/docs/fullsimlight/fsl/fsl-reg.png
new file mode 100644
index 0000000000000000000000000000000000000000..049d669fa1944e2957896e867a9d0f522c5fc44a
Binary files /dev/null and b/documentation/docs/fullsimlight/fsl/fsl-reg.png differ
diff --git a/documentation/docs/fullsimlight/fsl/fsl-sen.png b/documentation/docs/fullsimlight/fsl/fsl-sen.png
new file mode 100644
index 0000000000000000000000000000000000000000..f5e1b48cd1b842a7c2e0f10180f6963115e97b6d
Binary files /dev/null and b/documentation/docs/fullsimlight/fsl/fsl-sen.png differ
diff --git a/documentation/docs/fullsimlight/fsl/fsl-user.png b/documentation/docs/fullsimlight/fsl/fsl-user.png
new file mode 100644
index 0000000000000000000000000000000000000000..748c5dcc510febca6639c32305c70445e24bdc4e
Binary files /dev/null and b/documentation/docs/fullsimlight/fsl/fsl-user.png differ
diff --git a/documentation/docs/fullsimlight/fsl/fsl.png b/documentation/docs/fullsimlight/fsl/fsl.png
new file mode 100644
index 0000000000000000000000000000000000000000..a5ca0872f1eb2b5e9d0a3e6342de9d8beb6b37fe
Binary files /dev/null and b/documentation/docs/fullsimlight/fsl/fsl.png differ
diff --git a/documentation/docs/fullsimlight/fsl/index.md b/documentation/docs/fullsimlight/fsl/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..b833b12d0e084313aa09d3f3dac0df25230a988c
--- /dev/null
+++ b/documentation/docs/fullsimlight/fsl/index.md
@@ -0,0 +1,152 @@
+# fsl
+
+fsl is a GUI for FullSimLight introduced in GeoModel release 4.3.0. It allows users to configure their simulations in FullSimLight easily and without conflicts by providing a series of tabs which offer various configuration options. It can be ran from the command line through the fsl command.
+
+```bash
+./fsl
+```
+
+ Compatability of the simulation is ensured by the fsl interface by enabling and disabling options based on the selections made. Once the user has configured the simulation to their desire, they can save the configuration in a json file that can be used to run FullSimLight through the -c flag. 
+ 
+```bash
+./fullSimLight -c /path/to/config.json
+```
+ 
+Alternatively the user can run FullSimLight at any time within fsl itself with the current configuration. fsl also allows users to load in previously saved configurations through the **Open Configuration** option. 
+One can also load in a configuration by running fsl with the -c flag.
+
+```bash
+./fsl -c /path/to/config.json
+```
+
+
+## Main Tab
+
+
+{{ imgutils_image_caption('fsl-main.png', 
+   alt='fsl', 
+   cap='fsl main tab',
+   width ='700px',
+   urlFix=False) 
+}}
+
+The main tab allows configuration of the following parameters.
+
+- Geometry Input
+- Physics List
+- Number of Threads
+- Number of Events
+- G4UI Verbosity Commands
+
+It also contains the view button which shows the current configuration on the main display. The user can also run FullSimLight in the main display at any time with the current configuration by clicking on the FullSimLight button in the main tab. fsl provides similar buttons to run gmex and gmclash once a geometry input has been selected through the interface.
+
+
+## Generator Tab
+
+
+{{ imgutils_image_caption('fsl-gen.png', 
+   alt='fsl', 
+   cap='fsl generator tab',
+   width ='700px',
+   urlFix=False) 
+}}
+
+The generator tab shown above contains a list of event generators that can be selected for event generation. The options provided are
+
+- Particle Gun
+- Pythia
+- HepMC3 File
+- Generator Plugin
+
+### 1. Particle Gun
+
+To use a particle gun, the user must specify the particle type and momentum vector.
+
+### 2. Pythia
+
+To use Pythia one can select one of the pre-customized options which are
+
+- ttbar
+- higgs
+- minbias
+
+Alternatively one can also provide a custom file. 
+
+### 3. HepMC3 File
+
+HepMC3 files containing events can be used in FullSimLight in the both the standard Asciiv3 format (introduced in HepMC3) as well as the old Ascii format (used in HepMC and HepMC2).
+
+### 4. Generator Plugin
+
+In order to generate events one can also specify a plugin. Visit the Plugin Support page for more details.
+
+## Magnetic Field Tab
+
+
+{{ imgutils_image_caption('fsl-mag.png', 
+   alt='fsl', 
+   cap='fsl magnetic field tab',
+   width ='700px',
+   urlFix=False) 
+}}
+
+To set a Magnetic Field, there are two options
+
+- Fixed Axial
+- MAgnetic Field Plugin
+
+
+### 1. Fixed Axial
+
+Sets a constant Magnetic field in the z-direction at the specified magnitude. 
+
+### 2. Magnetic Field Plugin
+
+In order to generate a Magnetic Field one can also specify a plugin. Visit the Plugin Support page for more details. A custom ATLAS Magnetic Field Plugin comes with the GeoModel package ready to use. This is automatically contained in the atlas-conf.json configuration file provided by GeoModel. ***Warning: This Plugin requires the ATLAS Magnetic Field Map to be installed in a standard location. This Map is available to all ATLAS users on request.***
+
+
+## Regions Tab
+
+
+{{ imgutils_image_caption('fsl-reg.png', 
+   alt='fsl', 
+   cap='fsl regions tab',
+   width ='700px',
+   urlFix=False) 
+}}
+
+Regions can be added through the regions tab in FSL as shown above. For each region one must specify 
+
+- Region name
+- Root Logical Volumes
+- Electron cut (GeV)
+- Proton cut (GeV)
+- Positron cut (GeV)
+- Gamma cut (GeV)
+
+A list of ATLAS specific regions comes in the atlas-conf.json condfiguration file provided by GeoModel.
+
+## Sensitive Detectors Tab
+
+
+{{ imgutils_image_caption('fsl-sen.png', 
+   alt='fsl', 
+   cap='fsl sensitive detector tab',
+   width ='700px',
+   urlFix=False) 
+}}
+
+In order to add Sensitive Detectors one can create plugins which can then be added to the simulation through the menu shown above. Visit the Plugin Support page for more details.
+
+
+## User Actions Tab
+
+
+{{ imgutils_image_caption('fsl-user.png', 
+   alt='fsl', 
+   cap='fsl user action tab',
+   width ='700px',
+   urlFix=False) 
+}}
+
+In order to add User Actions one can create plugins which can then be added to the simulation through the menu shown above. Visit the Plugin Support page for more details.
diff --git a/documentation/docs/fullsimlight/plugin-support/index.md b/documentation/docs/fullsimlight/plugin-support/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..11545da20cd04cff9b9888cca6e6220499b4b8c4
--- /dev/null
+++ b/documentation/docs/fullsimlight/plugin-support/index.md
@@ -0,0 +1,184 @@
+# Plugin Support
+
+FullSimLight provides the user support with writing plugins by providing the abstract classes which one has the override. These abstract classes serve as a link to interface various Geant4 functionality with simulation using FullSimLight. Header files containing these abstract classes are automatically installed with FullSimLight installation.
+
+## User Actions & Event Generators
+<!---->
+The header file which contains the abstract classes to create plugins with User actions is ***FSLUserActionPlugin.h***. 
+
+
+```c++
+#ifndef _FSLUSERACTIONPLUGIN_H_
+#define _FSLUSERACTIONPLUGIN_H_
+class G4UserEventAction;
+class G4UserRunAction;
+class G4UserSteppingAction;
+class G4UserTrackingAction;
+class G4UserStackingAction;
+class G4VUserPrimaryGeneratorAction;
+
+class FSLUserActionPlugin {
+ 
+ public:
+
+  // Constructor
+  FSLUserActionPlugin()=default;
+  
+  // Destructor
+  virtual ~FSLUserActionPlugin()=default;
+  
+  // Typically a user action may inherit one or more of the five action
+  // types.  These routines should be overriden for each one. 
+  virtual G4UserEventAction    *getEventAction()    const { return nullptr;}
+  virtual G4UserRunAction      *getRunAction()      const { return nullptr;}
+  virtual G4UserSteppingAction *getSteppingAction() const { return nullptr;}
+  virtual G4UserTrackingAction *getTrackingAction() const { return nullptr;}
+  virtual G4UserStackingAction *getStackingAction() const { return nullptr;}
+  #A primary generator plugin inherits from this.
+  virtual G4VUserPrimaryGeneratorAction *getPrimaryGeneratorAction() const {return nullptr;}
+
+
+  
+ private:
+  
+  FSLUserActionPlugin (const FSLUserActionPlugin &)=delete;
+  FSLUserActionPlugin & operator=(const FSLUserActionPlugin &)=delete;
+
+};
+
+
+#endif
+```
+
+## Sensitive Detectors
+<!---->
+The header file which contains the abstract classes to create plugins with Sensitive detectors is ***FSLSensitiveDetectorPlugin.h***. 
+
+
+```c++
+#ifndef __FSLSensitiveDetectorPlugin_h__
+#define __FSLSensitiveDetectorPlugin_h__
+#include <vector>
+#include <string>
+
+
+class G4VSensitiveDetector;
+
+
+class FSLSensitiveDetectorPlugin {
+
+ public:
+  
+  // Public type definitions:
+  typedef std::vector<std::string>::const_iterator ConstIterator;
+  
+  // Constructor
+  FSLSensitiveDetectorPlugin();
+
+  // Destructor
+  virtual ~FSLSensitiveDetectorPlugin();
+
+  // Get the senstive detector
+  virtual G4VSensitiveDetector *getSensitiveDetector() const=0;
+
+  // Get the name of the hit collection into which hits go:
+  virtual std::string getHitCollectionName() const=0;
+
+  // Get the list of volume to which we attach this senstive detector
+  ConstIterator beginLogVolumeNames() const;
+  ConstIterator endLogVolumeNames() const;
+
+  // Add a logical volume for this senstive detector:
+  void addLogicalVolumeName(const std::string & logVolName);
+  
+ private:
+
+  std::vector<std::string> m_logVolNames;
+    
+  
+};
+
+
+inline FSLSensitiveDetectorPlugin::FSLSensitiveDetectorPlugin() {
+}
+
+inline FSLSensitiveDetectorPlugin::~FSLSensitiveDetectorPlugin() {
+}
+
+inline void FSLSensitiveDetectorPlugin::addLogicalVolumeName(const std::string & logVolName) {
+  m_logVolNames.push_back(logVolName);
+}
+
+inline FSLSensitiveDetectorPlugin::ConstIterator FSLSensitiveDetectorPlugin::beginLogVolumeNames() const {
+  return m_logVolNames.begin();
+}
+
+inline FSLSensitiveDetectorPlugin::ConstIterator FSLSensitiveDetectorPlugin::endLogVolumeNames() const {
+  return m_logVolNames.end();
+}
+
+#endif
+
+```
+
+## Physics List
+<!---->
+The header file which contains the abstract classes to create plugins with Physics lists is ***FSLPhysicsListPlugin.h***. 
+
+
+```c++
+#ifndef __FSLPhysicsListPlugin_h__
+#define __FSLPhysicsListPlugin_h__
+
+class G4VModularPhysicsList;
+
+class FSLPhysicsListPlugin
+{
+public:
+    FSLPhysicsListPlugin()=default;
+    ~FSLPhysicsListPlugin()=default;
+
+    virtual G4VModularPhysicsList* GetPhysicsList() const {return nullptr;}
+    virtual bool GetActivateRegionsFlag() const {return false;}
+
+};
+
+
+#endif //__FSLPhysicsListPlugin_h__
+
+```
+
+
+## Magnetic Field
+<!---->
+The header file which contains the abstract classes to create plugins with Magnetic fields is ***MagFieldPlugin.h***. 
+
+
+```c++
+#ifndef _MAGFIELDPLUGIN_H_
+#define _MAGFIELDPLUGIN_H_
+class G4MagneticField;
+class MagFieldPlugin {
+
+ public:
+
+  // Constructor
+  MagFieldPlugin()=default;
+  
+  // Destructor
+  virtual ~MagFieldPlugin()=default;
+  
+  virtual G4MagneticField *getField() =0;
+  
+ private:
+  
+  MagFieldPlugin (const MagFieldPlugin &)=delete;
+
+  MagFieldPlugin & operator=(const MagFieldPlugin &)=delete;
+};
+
+
+#endif
+
+
+```
diff --git a/documentation/docs/fullsimlight/plugins/index.md b/documentation/docs/fullsimlight/plugins/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..aec028e273e3ac3c96ddf6497e901d19d2c80562
--- /dev/null
+++ b/documentation/docs/fullsimlight/plugins/index.md
@@ -0,0 +1,312 @@
+# Plugins Example
+
+FullSimLight provides a convenient mechanism for users to extend their simulations through plugins in the form of shared libraries. Plugins can be used to add
+
+- User Actions
+- Sensititve Detectors 
+- Magnetic Field Maps
+- Physics Lists
+- Event Generators
+
+## Hits Plugin
+
+As a simple example, suppose you as the user want to keep track of the various particles and their positions as the simulation progresses. In particular, if you run the simulation with a certain number of events, then for each event you want to write to a file all the particles and their positions ***"hits"***.
+
+Geant4 provides classes to assist with this task. Namely the G4UserSteppingAction class contains the function
+
+```c++
+virtual void UserSteppingAction (const G4Step *aStep);
+```
+
+By overriding this function we can get particle positions and names through the G4Step object. Now since we also want to write out our hits to a file for each event, we can use the G4UserEventAction class, which conveniently provides the function
+ 
+```c++
+virtual void EndOfEventAction (const G4Event *anEvent);
+```
+which is called at the end of every event. We can also access the event ID through the G4Event object. Before proceding let us setup our project. Navigating to the directory of choice we can run on the terminal
+ 
+```bash
+mkdir HitsPlugin
+cd HitsPlugin
+touch CMakeLists.txt
+mkdir build
+mkdir src
+cd src
+touch HitsPlugin.cxx
+```
+This creates the directory structure
+
+```bash
+ HitsPlugin
+   ├── CMakeLists.txt
+   ├── build
+   └── src
+       └── HitsPlugin.cxx    
+```
+
+Opening up the CMakeLists.txt file, we call our project GenerateHitsPlugin and configure the file as follows
+
+```cmake
+# Set up the project.
+cmake_minimum_required( VERSION 3.1 )
+set(CMAKE_CXX_STANDARD 17)
+project( "GenerateHitsPlugin" )
+
+# Find and set the source file.
+file( GLOB SOURCES src/*.cxx )
+set(PROJECT_SOURCES ${SOURCES})
+
+# Set up the library.
+add_library(GenerateHitsPlugin SHARED ${SOURCES})
+
+#FullSimLight
+find_package(FullSimLight REQUIRED)
+
+#Geant4
+find_package(Geant4 REQUIRED)
+include(${Geant4_USE_FILE})
+
+#Link libraries and include directories
+target_link_libraries ( GenerateHitsPlugin PUBLIC FullSimLight ${Geant4_LIBRARIES})
+target_include_directories( GenerateHitsPlugin PUBLIC ${FullSimLight_INCLUDE_DIR})
+```
+
+Now we are ready to write our implementation of recording hits in HitsPlugin.cxx. This will require three classes and one additional function at the end of the file.
+
+```c++
+class GenerateHitsStep;
+class GenerateHitsEvent;
+class GenerateHitsPlugin;
+extern "C" GenerateHitsPlugin * createGenerateHitsPlugin();
+```
+
+- The first two classes GenerateHitsStep & GenerateHitsEvent will inherit from G4UserSteppingAction and G4UserEventAction respectively, since these contains the methods that are relevant for our purpose as discussed earlier. In general you will need one class for every type of User Action you decide to use.
+
+- The final class GenerateHitsPlugin is neccesary for defining the plugin and ***must have the same name as the name specified within the add_library command in the CMakeLists.txt file.*** This class will inherit from the FSLUserActionPlugin class, which is the abstract class provided by FullSimLight to allow it to interface with our custom defined User Actions. This class must always be defined.
+
+- Finally the function createGenerateHitsPlugin is neccesary for properly loading in the plugin to FullSimLight and ***must always have the name create + name of plugin class.*** This function must always be defined.
+
+Now that we have an outline of what we need to do. Let's first include all the relevant header files based on the above discussion
+
+```c++
+#include <iostream>
+#include <fstream>
+#include <map>
+#include "FullSimLight/FSLUserActionPlugin.h"
+#include "G4UserSteppingAction.hh"
+#include "G4UserEventAction.hh"
+#include "G4Step.hh"
+#include <G4Event.hh>
+```
+Next lets define a Hit struct which provides a convenient way of storing a particles position and ID
+
+```c++
+struct Hit{
+  float x;
+  float y;
+  float z;
+  unsigned int  id;
+};
+```
+Let us also create a map which associates various particles with an ID. This is useful as we can access particle names through the G4Step object and then associate those names with IDs for more efficient storage.
+
+```c++
+//Not a comprehensive list of all particles
+std::map<G4String, unsigned int> particle_ids { {"gamma", 1}, 
+{"e-", 2}, {"e+", 2}, {"mu-", 3}, {"mu+", 3}, };
+```
+
+We can now define our first class GenerateHitsStep which will inherit from G4UserSteppingAction and will record hits for us.
+
+```c++
+class GenerateHitsStep:
+public G4UserSteppingAction
+{
+public:
+    
+    
+    // Constructor:
+    GenerateHitsStep();
+     
+    // Destructor:
+    ~GenerateHitsStep();
+     
+    //Overriding virtual function with our implementation
+    void UserSteppingAction(const G4Step* step) override;
+    
+    //A vector to store hits
+    std::vector<Hit> hits;
+    
+    //A function to clear the hits vector when a new event starts
+    void clearhits(){hits.clear();}
+    
+
+ };
+                            
+GenerateHitsStep::GenerateHitsStep(){}
+
+GenerateHitsStep::~GenerateHitsStep() {}
+
+
+void GenerateHitsStep::UserSteppingAction(const G4Step* step){
+ 
+    //Creating a Hit instance
+    Hit hit_inst;
+    
+    //Assigning the Hit position
+    hit_inst.x = step->GetPreStepPoint()->GetPosition()[0];
+    hit_inst.y = step->GetPreStepPoint()->GetPosition()[1];
+    hit_inst.z = step->GetPreStepPoint()->GetPosition()[2];
+    
+    //Checking to see if particle is in particle map defined above, if so assigning the corresponding ID
+    if (particle_ids.count(step->GetTrack()->GetParticleDefinition()->GetParticleName())>0)
+    {
+    hit_inst.id = particle_ids.find(step->GetTrack()->GetParticleDefinition()->GetParticleName())->second;
+    }
+    
+    //Otherwise assigning it a default particle id of 9.
+    else
+    {
+    hit_inst.id = 9;
+    }
+    //Adding hit to hits vector
+    hits.push_back(hit_inst);
+
+}
+
+```
+Next we define GenerateHitsEvent class which will inherit from G4UserEventAction and will write hits to a file at the end of every event.
+
+```c++
+class GenerateHitsEvent:
+public G4UserEventAction
+ {
+public:
+    
+     // Constructor:
+     GenerateHitsEvent();
+     
+     // Destructor:
+    ~GenerateHitsEvent();
+     
+     //Overriding virtual function with our implementation. 
+     //Function called at the end of every event.
+     void EndOfEventAction(const G4Event* evt) override;
+     
+     //Function to set a Stepping Action
+     void SetSteppingAction(GenerateHitsStep* stepact){step = stepact;}
+     
+ private:
+     
+     //Instance of stepping action to get hits from
+     GenerateHitsStep* step;
+     
+     //Private member to store the event ID
+     unsigned int event_ID;
+     
+     //Vector to store hits
+     std::vector<Hit> hits;
+     
+     
+     
+ };
+
+
+GenerateHitsEvent::GenerateHitsEvent(){}
+
+GenerateHitsEvent::~GenerateHitsEvent(){}
+
+void GenerateHitsEvent::EndOfEventAction(const G4Event* evt)
+{
+    //Get Event ID
+    event_ID = evt->GetEventID();
+    
+    //Get hits from the stepping action
+    hits = step->hits;
+
+    /* Implement your own code to write
+        to a file */
+    
+    //Clear hits vector in the stepping action as end of event is reached.
+    step->clearhits();
+}
+
+```
+
+Now we need to define the GenerateHitsPlugin class which will provide the interface with FullSimLight. This class will inherit from FSLUserActionPlugin class and override methods depending upon the User Actions used.
+
+```c++
+class GenerateHitsPlugin:public FSLUserActionPlugin {
+    
+public:
+    
+    //Constructor
+    GenerateHitsPlugin();
+    
+    //overriding functions in FSLUserActionPlugin based on the User Actions we've used.
+    //Since we used G4UserSteppingAction & G4UserEventAction we override getSteppingAction and getEventAction.
+    //Similar procedure for other actions.
+    //These overrided functions just return a new instance of the corresponding implementation class.
+    //For example getEventAction would return an instance of GenerateHitsEvent in this case.
+    //Similarly getSteppingAction would return an instance of GenerateHitsStep.
+    //Similar procedure if other User Actions were used.
+    virtual G4UserSteppingAction *getSteppingAction() const final override;
+    virtual G4UserEventAction *getEventAction() const final override;
+
+    //New Instances of implementation classes
+    GenerateHitsEvent* eventaction = new GenerateHitsEvent();
+    GenerateHitsStep* stepaction = new GenerateHitsStep();
+
+};
+
+GenerateHitsPlugin::GenerateHitsPlugin()
+{
+//Passing the stepping action into the event action as required by our implementation.
+eventaction->SetSteppingAction(stepaction);
+}
+
+G4UserSteppingAction *GenerateHitsPlugin::getSteppingAction() const {
+  return stepaction;
+}
+
+G4UserEventAction *GenerateHitsPlugin::getEventAction() const {
+    return eventaction;
+    
+}
+```
+
+Finally we need to define the function createGenerateHitsPlugin() which will return a new instance of our plugin class.
+
+
+```c++
+
+extern "C" GenerateHitsPlugin *createGenerateHitsPlugin() {
+    return new GenerateHitsPlugin();
+}
+
+```
+
+With the implmentation completed, we can now move into the build folder and run.
+
+```bash
+cmake ..
+make
+```
+
+In the build folder you will see
+
+```bash
+libGenerateHitsPlugin.dylib (Mac)
+libGenerateHitsPlugin.so (Linux)
+```
+
+Our plugin is ready to use! We can now open up fsl by running the fsl command and can add our plugin in the User Actions tab as shown below
+
+{{ imgutils_image_caption('plugin.png', 
+   alt='fsl', 
+   cap='fsl User Actions tab',
+   width ='700px',
+   urlFix=False) 
+}}
+
+Once we have configured the rest of the simulation to our desire we can run FullSimLight and record hits.
diff --git a/documentation/docs/fullsimlight/plugins/plugin.png b/documentation/docs/fullsimlight/plugins/plugin.png
new file mode 100644
index 0000000000000000000000000000000000000000..d54b589ac55a7019a95f79341f4551ace520e866
Binary files /dev/null and b/documentation/docs/fullsimlight/plugins/plugin.png differ
diff --git a/documentation/mkdocs.yml b/documentation/mkdocs.yml
index a9be1276c554a3bc1252d8d09fe3345f995cc1f6..1ff5f59196d147201de401b7843b071e60a6f5e3 100755
--- a/documentation/mkdocs.yml
+++ b/documentation/mkdocs.yml
@@ -36,6 +36,9 @@ nav:
         - 'GeoModelGeantino': 'fullsimlight/gmgeantino/index.md'
         - 'GeoModelMassCalculator': 'fullsimlight/gmmasscalc/index.md'
         - 'GeoModel2GDML': 'fullsimlight/gm2gdml/index.md'
+        - 'fsl': 'fullsimlight/fsl/index.md'
+        - 'Plugin Examples': 'fullsimlight/plugins/index.md'
+        - 'Plugin Support': 'fullsimlight/plugin-support/index.md'
     - FAQ: 'faq.md'
     - For Developers:
         - 'Build the Libraries and Tools': 'dev/index.md'