diff --git a/.appveyor.yml b/.appveyor.yml
index fb30afe4..6bbe22d5 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -9,8 +9,8 @@ platform:
 
 environment:
   MSVC_DEFAULT_OPTIONS: ON
-  BOOST_ROOT_DIR: "C:\\Libraries\\boost_1_60_0"
-  BOOST_LIB_DIR: "C:\\Libraries\\boost_1_60_0\\lib32-msvc-14.0"
+  BOOST_ROOT_DIR: "C:\\Libraries\\boost_1_63_0"
+  BOOST_LIB_DIR: "C:\\Libraries\\boost_1_63_0\\lib32-msvc-14.0"
   MYSQL_PWD: "Password12!"
 
 services:
diff --git a/.gitignore b/.gitignore
index 0747ffb3..f057cbaf 100644
--- a/.gitignore
+++ b/.gitignore
@@ -38,6 +38,7 @@ build/
 *.la
 *.a
 *.lib
+*.exp
 
 # Executables
 *.exe
diff --git a/.travis.yml b/.travis.yml
index 21eb7833..d8158ae9 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -29,9 +29,9 @@ cache:
 before_install:
   - eval "${MATRIX_EVAL}"
   - gem install --no-ri --no-rdoc mtime_cache
+  - sudo add-apt-repository -y ppa:rexut/recoil
   - sudo apt-get update
-  - sudo apt-get install -y libboost-dev libboost-all-dev
-  - sudo apt-get install -y libmysqlclient-dev libmysqlcppconn-dev
+  - sudo apt-get install -y libboost1.63-dev libboost1.63-all-dev
 
 # Build steps
 script:
@@ -39,6 +39,6 @@ script:
   - mtime_cache src/**/*.{%{cpp}} -c .mtime_cache/cache.json
   - mkdir -p build
   - cd build
-  - cmake .. -DSAPPHIRE_BOOST_VER="1.54.0" && make -j 3
+  - cmake .. -DSAPPHIRE_BOOST_VER="1.63.0" && make -j 3
   - cd ..
   - bash sql_import.sh
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 997abb3d..54f7d380 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,8 +4,9 @@ project (Sapphire)
 
 set(CMAKE_BINARY_DIR ${CMAKE_SOURCE_DIR}/bin)
 
-set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR})
-set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR})
+set(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/bin)
+set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
+set(EXECUTABLE_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
 
 set(PROJECT_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/include)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/cmake)
@@ -42,7 +43,6 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/src/servers/Server_Common/Version.cp
 
 ##########################################################################
 # Common include folders
-include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/libraries/external/ChaiScript-6.0.0/include/")
 include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/libraries/sapphire/datReader/")
 include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/libraries/sapphire/mysqlConnector/")
 include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src")
@@ -66,3 +66,5 @@ add_subdirectory("src/tools/exd_struct_gen")
 add_subdirectory("src/tools/exd_struct_test")
 add_subdirectory("src/tools/quest_parser")
 add_subdirectory("src/tools/pcb_reader")
+
+add_subdirectory("scripts/native")
diff --git a/bin/config/settings_rest.xml b/bin/config/settings_rest.xml
index ddadaf67..e3059921 100644
--- a/bin/config/settings_rest.xml
+++ b/bin/config/settings_rest.xml
@@ -6,7 +6,7 @@
       <!-- Ip the lobby server listens on -->
       <ListenIp>127.0.0.1</ListenIp>
       <!-- Path of FFXIV dat files -->
-      <DataPath>C:\\SquareEnix\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv</DataPath>
+      <DataPath>H:\\SteamLibrary\\steamapps\\common\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv</DataPath>
       <!-- <DataPath>/opt/sapphire_3_15_0/bin/sqpack</DataPath> -->
       <!-- IP of the lobby server -->
       <LobbyHost>127.0.0.1</LobbyHost>
diff --git a/bin/config/settings_zone.xml b/bin/config/settings_zone.xml
index 18d33bf6..a0d56a0a 100644
--- a/bin/config/settings_zone.xml
+++ b/bin/config/settings_zone.xml
@@ -1,14 +1,26 @@
 <Settings>
-
    <General>
       <!-- Port the zone server accepts game conenctions on -->
       <ListenPort>54992</ListenPort> 
       <!-- Ip the zone server conenctions on -->
       <ListenIp>127.0.0.1</ListenIp>
       <!-- Path of FFXIV dat files -->
-      <DataPath>C:\\SquareEnix\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv</DataPath>
+      <DataPath>H:\\SteamLibrary\\steamapps\\common\\FINAL FANTASY XIV - A Realm Reborn\\game\\sqpack\\ffxiv</DataPath>
+
+      <Scripts>
+      	<!-- where compiled scripts are placed -->
+      	<Path>./compiledscripts/</Path>
+      	<CachePath>./cache/</CachePath>
+
+      	<HotSwap>
+      		<Enabled>1</Enabled>
+      		<BuildDir>../cmake-build-debug/</BuildDir>
+      		<BuildCmd>cmake --build %1% --target %2%</BuildCmd>
+      	</HotSwap>
+      </Scripts>
+
       <!-- Path of Chai script files -->
-      <ScriptPath>../scripts/chai</ScriptPath>
+      <ScriptPath>./compiledscripts/</ScriptPath>
       <!-- Connection settings for the mysql db -->
       <Mysql>
          <Host>127.0.0.1</Host>
diff --git a/cmake/mysql.cmake b/cmake/mysql.cmake
index 7e3ceccf..77106bc9 100644
--- a/cmake/mysql.cmake
+++ b/cmake/mysql.cmake
@@ -11,6 +11,7 @@ if(UNIX)
         /usr/local/mysql/include/mysql
         $ENV{ProgramFiles}/MySQL/*/include
         $ENV{SystemDrive}/MySQL/*/include
+        ${LIBRARY_DIR}/external/MySQL/
     )
 
     if(MYSQL_INCLUDE_DIR)
diff --git a/scripts/native/CMakeLists.txt b/scripts/native/CMakeLists.txt
new file mode 100644
index 00000000..334c9f01
--- /dev/null
+++ b/scripts/native/CMakeLists.txt
@@ -0,0 +1,47 @@
+cmake_minimum_required(VERSION 3.0)
+project(Sapphire_Script)
+
+file(GLOB SCRIPT_INCLUDE_FILES "${CMAKE_CURRENT_SOURCE_DIR}/*.h")
+file(GLOB_RECURSE SCRIPT_FILES "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp")
+
+include_directories("${CMAKE_SOURCE_DIR}/src/servers/")
+include_directories("${CMAKE_SOURCE_DIR}/src/servers/Server_Zone/")
+
+if(MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Yc${CMAKE_CURRENT_SOURCE_DIR}/ScriptObject.h /FI${CMAKE_CURRENT_SOURCE_DIR}/ScriptObject.h")
+endif()
+
+message( "exec: ${EXECUTABLE_OUTPUT_DIRECTORY}" )
+
+set( SCRIPT_LIB_DIR "${EXECUTABLE_OUTPUT_DIRECTORY}/compiledscripts/" )
+set( EXECUTABLE_OUTPUT_PATH "${SCRIPT_LIB_DIR}")
+set( LIBRARY_OUTPUT_PATH "${SCRIPT_LIB_DIR}")
+set( RUNTIME_OUTPUT_DIRECTORY "${SCRIPT_LIB_DIR}")
+
+foreach(_sourcefile ${SCRIPT_FILES})
+    get_filename_component(_file "${_sourcefile}" NAME_WE)
+    add_library("${_file}" MODULE "${_sourcefile}" "${SCRIPT_INCLUDE_FILES}")
+
+    if(MSVC)
+        set_source_files_properties("${_file}" PROPERTIES
+            COMPILE_FLAGS "/Yc${CMAKE_CURRENT_SOURCE_DIR}/ScriptObject.h"
+        )
+        set_target_properties(${_file} PROPERTIES
+            CXX_STANDARD 14
+            CXX_STANDARD_REQUIRED ON
+            CXX_EXTENSIONS ON
+            LIBRARY_OUTPUT_DIRECTORY_DEBUG "${SCRIPT_LIB_DIR}"
+            LIBRARY_OUTPUT_DIRECTORY_RELEASE "${SCRIPT_LIB_DIR}"
+            LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO "${SCRIPT_LIB_DIR}"
+            LIBRARY_OUTPUT_DIRECTORY_MINSIZEREL "${SCRIPT_LIB_DIR}"
+        )
+    endif()
+
+    target_link_libraries("${_file}" server_zone)
+
+    add_custom_command(TARGET "${_file}" POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E remove "${SCRIPT_LIB_DIR}/${_file}.exp"
+        COMMAND ${CMAKE_COMMAND} -E remove "${SCRIPT_LIB_DIR}/${_file}.lib"
+        COMMAND ${CMAKE_COMMAND} -E remove "${SCRIPT_LIB_DIR}/${_file}.ilk"
+    )
+endforeach(_sourcefile ${SCRIPT_FILES})
\ No newline at end of file
diff --git a/scripts/native/CmnDef/CmnDefCutSceneReplay.cpp b/scripts/native/CmnDef/CmnDefCutSceneReplay.cpp
new file mode 100644
index 00000000..f190b7d5
--- /dev/null
+++ b/scripts/native/CmnDef/CmnDefCutSceneReplay.cpp
@@ -0,0 +1,38 @@
+#include "../ScriptObject.h"
+
+class CmnDefCutSceneReplay : public EventScript
+{
+public:
+   CmnDefCutSceneReplay() : EventScript( "CmnDefCutSceneReplay", 721028 )
+   {}
+
+   void Scene00000( Entity::Player& player )
+   {
+      auto callback = [ this ]( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
+      {
+         if( param2 != 0 )
+         {
+            Scene00001( player, param2 );
+         }
+      };
+
+      player.eventPlay( getId(), 0, 0x2000, 0, 1, callback );
+   }
+
+   void Scene00001( Entity::Player& player, uint16_t returnScene )
+   {
+      auto callback = []( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
+      {
+         // todo: this is fucked
+      };
+
+      player.eventPlay( getId(), 1, 0xFB2EC8F8, 0, 1, returnScene, callback );
+   }
+
+   void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override
+   {
+      Scene00000( player );
+   }
+};
+
+EXPORT_SCRIPTOBJECT( CmnDefCutSceneReplay )
\ No newline at end of file
diff --git a/scripts/native/CmnDef/CmnDefInnBed.cpp b/scripts/native/CmnDef/CmnDefInnBed.cpp
new file mode 100644
index 00000000..0238eeac
--- /dev/null
+++ b/scripts/native/CmnDef/CmnDefInnBed.cpp
@@ -0,0 +1,58 @@
+#include "../ScriptObject.h"
+
+class CmnDefInnBed : public EventScript
+{
+public:
+   CmnDefInnBed() : EventScript( "CmnDefInnBed", 720916 )
+   {}
+
+   // menu
+   void Scene00000( Entity::Player& player )
+   {
+      auto callback = [ this ]( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
+      {
+         if( param2 > 0 )
+            Scene00001( player, param2 );
+      };
+
+      player.eventPlay( getId(), 0, 0x2000, 0, 1, callback );
+   }
+
+   // lay down
+   void Scene00001( Entity::Player& player, uint16_t param )
+   {
+      auto callback = [ this ]( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
+      {
+         Scene00002( player, param2 );
+      };
+
+      player.eventPlay( getId(), 1, 0xF32E48F8, 0, 1, param, callback );
+   }
+
+   // logout
+   void Scene00002( Entity::Player& player, uint16_t param )
+   {
+      player.eventPlay( getId(), 2, 0xF32E48F8, 0, 1, param, nullptr );
+   }
+
+   // wake up
+   void Scene00100( Entity::Player& player )
+   {
+      auto callback = []( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
+      {};
+
+      player.eventPlay( getId(), 100, 0x800, 0, 0, callback );
+   }
+
+   void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override
+   {
+      Scene00000( player );
+   }
+
+   void onEnterZone( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2 ) override
+   {
+      Scene00100( player );
+   }
+};
+
+EXPORT_SCRIPTOBJECT( CmnDefInnBed )
\ No newline at end of file
diff --git a/scripts/native/CmnDef/CmnDefLinkShell.cpp b/scripts/native/CmnDef/CmnDefLinkShell.cpp
new file mode 100644
index 00000000..b85b2d9b
--- /dev/null
+++ b/scripts/native/CmnDef/CmnDefLinkShell.cpp
@@ -0,0 +1,60 @@
+#include "../ScriptObject.h"
+
+#define ACTION_CREATE 2
+#define ACTION_RENAME 3
+#define ACTION_REMOVE 4
+
+class CmnDefLinkShell : public EventScript
+{
+public:
+   CmnDefLinkShell() : EventScript( "CmnDefLinkShell", 0xB0006 )
+   {}
+
+   void Scene00001( Entity::Player& player )
+   {
+      auto callback = [ this ]( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
+      {
+         switch( param2 )
+         {
+            case ACTION_CREATE:
+               Scene00002( player );
+               break;
+
+            case ACTION_RENAME:
+               Scene00003( player );
+               break;
+
+            case ACTION_REMOVE:
+               Scene00004( player );
+               break;
+         }
+      };
+
+      player.eventPlay( getId(), 1, 0, 0, 0, callback );
+   }
+
+   // create linkshell
+   void Scene00002( Entity::Player& player )
+   {
+      player.eventPlay( getId(), 2, 0, 0, 0 );
+   }
+
+   // rename linkshell
+   void Scene00003( Entity::Player& player )
+   {
+      player.eventPlay( getId(), 3, 0, 0, 0 );
+   }
+
+   // remove linkshell
+   void Scene00004( Entity::Player& player )
+   {
+      player.eventPlay( getId(), 4, 0, 0, 0 );
+   }
+
+   void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override
+   {
+      Scene00001( player );
+   }
+};
+
+EXPORT_SCRIPTOBJECT( CmnDefLinkShell )
\ No newline at end of file
diff --git a/scripts/native/CmnDef/HouFurOrchestrion.cpp b/scripts/native/CmnDef/HouFurOrchestrion.cpp
new file mode 100644
index 00000000..6544712c
--- /dev/null
+++ b/scripts/native/CmnDef/HouFurOrchestrion.cpp
@@ -0,0 +1,20 @@
+#include "../ScriptObject.h"
+
+class HouFurOrchestrionDef : public EventScript
+{
+public:
+   HouFurOrchestrionDef() : EventScript( "HouFurOrchestrionDef", 721226 )
+   {}
+
+   void Scene00000( Entity::Player& player )
+   {
+      player.eventPlay( getId(), 0, 0x2000, 0, 1 );
+   }
+
+   void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override
+   {
+      Scene00000( player );
+   }
+};
+
+EXPORT_SCRIPTOBJECT( HouFurOrchestrionDef )
\ No newline at end of file
diff --git a/scripts/native/ScriptObject.h b/scripts/native/ScriptObject.h
new file mode 100644
index 00000000..108b8df0
--- /dev/null
+++ b/scripts/native/ScriptObject.h
@@ -0,0 +1,10 @@
+#ifndef SAPPHIRE_SCRIPTOBJECT_H
+#define SAPPHIRE_SCRIPTOBJECT_H
+
+#include <Script/NativeScriptApi.h>
+#include <Forwards.h>
+#include <Actor/Actor.h>
+#include <Actor/Player.h>
+
+
+#endif //SAPPHIRE_SCRIPTOBJECT_H
diff --git a/scripts/native/action/ActionSprint3.cpp b/scripts/native/action/ActionSprint3.cpp
new file mode 100644
index 00000000..d1312d03
--- /dev/null
+++ b/scripts/native/action/ActionSprint3.cpp
@@ -0,0 +1,15 @@
+#include "../ScriptObject.h"
+
+class ActionSprint3 : public ActionScript
+{
+public:
+   ActionSprint3() : ActionScript( "ActionSprint3", 3 )
+   {}
+
+   void onCastFinish( Core::Entity::Player& player, Core::Entity::Actor& targetActor ) override
+   {
+      player.addStatusEffectByIdIfNotExist( 50, 20000, player, 30 );
+   }
+};
+
+EXPORT_SCRIPTOBJECT( ActionSprint3 )
\ No newline at end of file
diff --git a/scripts/native/aetheryte/Aethernet.cpp b/scripts/native/aetheryte/Aethernet.cpp
new file mode 100644
index 00000000..d2ac491d
--- /dev/null
+++ b/scripts/native/aetheryte/Aethernet.cpp
@@ -0,0 +1,48 @@
+#include "../ScriptObject.h"
+
+#define ACTION_ATTUNE 0x13
+
+#define AetheryteBaseId 0x50000
+#define AETHERYTE_MENU_AETHERNET 1
+#define AETHERYTE_MENU_HOUSING 2
+#define AETHERYTE_MENU_HOME_POINT 3
+#define AETHERYTE_MENU_FAVORITE_POINT 4
+#define AETHERYTE_MENU_FAVORITE_POINT_SECURITY_TOKEN 5
+
+class Aethernet : public EventScript
+{
+public:
+   Aethernet() : EventScript( "Aethernet", EVENTSCRIPT_AETHERNET_ID )
+   {}
+
+   void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override
+   {
+      if( player.isAetheryteRegistered( eventId & 0xFFFF ) )
+      {
+         player.eventPlay( eventId, 2, 0, []( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
+         {
+            if( param1 == 256 )
+            {
+               player.teleport( param2, 2 );
+            }
+         } );
+      }
+      else
+      {
+         player.eventActionStart( eventId, ACTION_ATTUNE, []( Entity::Player& player, uint32_t eventId, uint64_t additional )
+         {
+            player.registerAetheryte( eventId & 0xFFFF );
+            player.eventPlay( eventId, 3, 0, 0, 0 );
+         },
+         [] ( Entity::Player& ply, uint32_t evntId, uint64_t additional )
+         {
+
+         }, 0 );
+
+         player.unlock();
+      }
+
+   }
+};
+
+EXPORT_SCRIPTOBJECT( Aethernet )
\ No newline at end of file
diff --git a/scripts/native/aetheryte/Aetheryte.cpp b/scripts/native/aetheryte/Aetheryte.cpp
new file mode 100644
index 00000000..c4e0e0b0
--- /dev/null
+++ b/scripts/native/aetheryte/Aetheryte.cpp
@@ -0,0 +1,70 @@
+#include "../ScriptObject.h"
+
+#define ACTION_ATTUNE 0x13
+#define ACTION_TELEPORT 0x4
+
+#define AetheryteBaseId 0x50000
+#define AETHERYTE_MENU_AETHERNET 1
+#define AETHERYTE_MENU_HOUSING 2
+#define AETHERYTE_MENU_HOME_POINT 3
+#define AETHERYTE_MENU_FAVORITE_POINT 4
+#define AETHERYTE_MENU_FAVORITE_POINT_SECURITY_TOKEN 5
+
+class Aetheryte : public EventScript
+{
+public:
+   Aetheryte() : EventScript( "Aetheryte", EVENTSCRIPT_AETHERYTE_ID )
+   {}
+
+   void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) override
+   {
+      if( player.isAetheryteRegistered( eventId & 0xFFFF ) )
+      {
+         player.eventPlay( eventId, 0, 1, []( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
+         {
+            if( param1 == 256 ) // set homepoint
+            {
+               player.setHomepoint( eventId & 0xFFFF );
+               player.sendQuestMessage( eventId, 2, 0xEA, 0, 0 );
+            }
+            else if( param1 == 512 ) // aethernet access
+            {
+               if( param2 == 4 )
+               {
+                  player.teleport( param3, 2 );
+               }
+               else if( param2 == 2 ) // register favored destination
+               {
+
+               }
+//               else if( param2 == 0xC3E1 ) // register free destination
+//               {
+//
+//               }
+
+            }
+         } );
+      }
+      else
+      {
+         player.eventActionStart( eventId, ACTION_ATTUNE, []( Entity::Player& player, uint32_t eventId, uint64_t additional )
+         {
+            player.registerAetheryte( eventId & 0xFFFF );
+
+            if( player.isActionLearned( ACTION_TELEPORT ) )
+            {
+               player.sendQuestMessage( eventId, 0, 2, 0, 0 );
+            }
+            else
+            {
+               player.sendQuestMessage( eventId, 0, 1, 1, 0 );
+               player.learnAction( ACTION_TELEPORT );
+            }
+         },
+         [] ( Entity::Player& player, uint32_t eventId, uint64_t additional )
+         {}, 0 );
+      }
+   }
+};
+
+EXPORT_SCRIPTOBJECT( Aetheryte )
\ No newline at end of file
diff --git a/scripts/native/opening/OpeningGridania.cpp b/scripts/native/opening/OpeningGridania.cpp
new file mode 100644
index 00000000..2a9e5e6b
--- /dev/null
+++ b/scripts/native/opening/OpeningGridania.cpp
@@ -0,0 +1,91 @@
+#include "../ScriptObject.h"
+
+#define ERANGE_HOWTO_ANN_AND_QUEST 2117539
+#define ERANGE_HOWTO_QUEST_REWARD 2366417
+#define ERANGE_SEQ_1_CLOSED_1 2351918
+#define POS_SEQ_1_CLOSED_RETURN_1 2351921
+#define ERANGE_SEQ_1_CLOSED_2 2351919
+#define POS_SEQ_1_CLOSED_RETURN_2 2351921
+#define ERANGE_ALWAYS_CLOSED_1 2280846
+#define POS_ALWAYS_CLOSED_RETURN_1 2320804
+#define ENPC_ALWAYS_CLOSED_1 2367988
+#define ERANGE_ALWAYS_CLOSED_3 2280851
+#define POS_ALWAYS_CLOSED_RETURN_3 2320811
+#define ENPC_ALWAYS_CLOSED_3 2563491
+#define BGM_MUSIC_ZONE_FST_TWN 1003
+#define NCUT_FST_1 3
+#define NCUT_FST_2 53
+#define NCUT_FST_3 226
+#define ENPC_QUEST_OFFER 1985150
+#define NCUT_LIGHT_ALL 2
+#define NCUT_LIGHT_FST_1 147
+#define NCUT_LIGHT_FST_2 146
+
+class OpeningGridania : public EventScript
+{
+public:
+   OpeningGridania() : EventScript( "OpeningGridania", 1245186 )
+   {}
+
+   void Scene00000( Entity::Player& player )
+   {
+      auto callback = [ this ]( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
+      {
+         player.setOpeningSequence( 1 );
+         Scene00001( player );
+      };
+
+      player.eventPlay( getId(), 0, 0x04AC05, 0, 1, callback );
+   }
+
+   void Scene00001( Entity::Player& player )
+   {
+      player.eventPlay( getId(), 1, 0x2001, 1, 0x32 );
+   }
+
+   void Scene00020( Entity::Player& player )
+   {
+      player.eventPlay( getId(), 20, 0x2001, 0, 1 );
+   }
+
+   void Scene00030( Entity::Player& player )
+   {
+      player.eventPlay( getId(), 30, 0x2001, 0, 0 );
+   }
+
+   void Scene00040( Entity::Player& player )
+   {
+      auto callback = [ this ]( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2, uint16_t param3 )
+      {
+         if( player.getOpeningSequence() == 2 )
+         {
+            // update the instance boundaries
+            Scene00030( player );
+         }
+      };
+   }
+
+   ///////////////////////////////
+
+   void onEnterZone( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2 ) override
+   {
+      if( player.getOpeningSequence() == 0 )
+      {
+         Scene00000( player );
+      }
+      else
+      {
+         Scene00040( player );
+      }
+   }
+
+   void onWithinRange( Entity::Player& player, uint32_t eventId, uint32_t param1, float x, float y, float z ) override
+   {
+      if( param1 == ERANGE_SEQ_1_CLOSED_1 || param1 == ERANGE_SEQ_1_CLOSED_2 )
+      {
+         Scene00020( player );
+      }
+   }
+};
+
+EXPORT_SCRIPTOBJECT( OpeningGridania )
\ No newline at end of file
diff --git a/scripts/native/opening/OpeningLimsa.cpp b/scripts/native/opening/OpeningLimsa.cpp
new file mode 100644
index 00000000..e69de29b
diff --git a/scripts/native/opening/OpeningUldah.cpp b/scripts/native/opening/OpeningUldah.cpp
new file mode 100644
index 00000000..e69de29b
diff --git a/src/servers/Server_Common/Script/ChaiscriptStdLib.cpp b/src/servers/Server_Common/Script/ChaiscriptStdLib.cpp
deleted file mode 100644
index 282d4ecb..00000000
--- a/src/servers/Server_Common/Script/ChaiscriptStdLib.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <chaiscript/chaiscript_stdlib.hpp>
-#include <chaiscript/chaiscript.hpp>
-#include "ChaiscriptStdLib.h"
-#include <boost/make_shared.hpp>
-
-std::shared_ptr< chaiscript::Module > Core::Scripting::create_chaiscript_stdlib()
-{
-   return chaiscript::Std_Lib::library();
-}
-
-boost::shared_ptr< chaiscript::ChaiScript > Core::Scripting::create_chaiscript()
-{
-   auto chai = boost::make_shared< chaiscript::ChaiScript >();
-   //create_chaiscript_bindings( chai );
-   return chai;
-}
\ No newline at end of file
diff --git a/src/servers/Server_Common/Script/ChaiscriptStdLib.h b/src/servers/Server_Common/Script/ChaiscriptStdLib.h
deleted file mode 100644
index f3e346d8..00000000
--- a/src/servers/Server_Common/Script/ChaiscriptStdLib.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef CHAISCRIPT_STDLIB
-#define CHAISCRIPT_STDLIB
-
-#include <boost/shared_ptr.hpp>
-
-namespace chaiscript 
-{
-  class Module;
-  class ChaiScript;
-}
-
-namespace Core { namespace Scripting {
-
-std::shared_ptr<chaiscript::Module> create_chaiscript_stdlib();
-boost::shared_ptr< chaiscript::ChaiScript > create_chaiscript();
-
-} }
-
-#endif
diff --git a/src/servers/Server_Zone/CMakeLists.txt b/src/servers/Server_Zone/CMakeLists.txt
index 308f3ab7..bfb8183f 100644
--- a/src/servers/Server_Zone/CMakeLists.txt
+++ b/src/servers/Server_Zone/CMakeLists.txt
@@ -46,6 +46,8 @@ set_target_properties(server_zone PROPERTIES
     CXX_STANDARD 14
     CXX_STANDARD_REQUIRED ON
     CXX_EXTENSIONS ON
+    ENABLE_EXPORTS ON
+    WINDOWS_EXPORT_ALL_SYMBOLS ON
     RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_CURRENT_SOURCE_DIR}/../../../bin/"
     RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_CURRENT_SOURCE_DIR}/../../../bin/"
     RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_CURRENT_SOURCE_DIR}/../../../bin/"
diff --git a/src/servers/Server_Zone/DebugCommand/DebugCommandHandler.cpp b/src/servers/Server_Zone/DebugCommand/DebugCommandHandler.cpp
index 55b63d1d..9f6a39dd 100644
--- a/src/servers/Server_Zone/DebugCommand/DebugCommandHandler.cpp
+++ b/src/servers/Server_Zone/DebugCommand/DebugCommandHandler.cpp
@@ -19,6 +19,7 @@
 #include "Network/PacketWrappers/InitUIPacket.h"
 #include "Network/GameConnection.h"
 #include "Script/ScriptManager.h"
+#include "Script/NativeScriptManager.h"
 
 #include "Actor/Player.h"
 #include "Actor/BattleNpc.h"
@@ -30,6 +31,7 @@
 #include "StatusEffect/StatusEffect.h"
 #include "Session.h"
 #include <boost/make_shared.hpp>
+#include <boost/format.hpp>
 
 
 #include <cinttypes>
@@ -48,11 +50,11 @@ Core::DebugCommandHandler::DebugCommandHandler()
    registerCommand( "add", &DebugCommandHandler::add, "Loads and injects a premade Packet.", 1 );
    registerCommand( "inject", &DebugCommandHandler::injectPacket, "Loads and injects a premade packet.", 1 );
    registerCommand( "injectc", &DebugCommandHandler::injectChatPacket, "Loads and injects a premade chat packet.", 1 );
-   registerCommand( "script_reload", &DebugCommandHandler::scriptReload, "Reload all server scripts", 1 );
    registerCommand( "nudge", &DebugCommandHandler::nudge, "Nudges you forward/up/down", 1 );
    registerCommand( "info", &DebugCommandHandler::serverInfo, "Send server info", 0 );
    registerCommand( "unlock", &DebugCommandHandler::unlockCharacter, "Unlock character", 1 );
    registerCommand( "help", &DebugCommandHandler::help, "Shows registered commands", 0 );
+   registerCommand( "script", &DebugCommandHandler::script, "Server script utilities", 1 );
 }
 
 // clear all loaded commands
@@ -117,13 +119,6 @@ void Core::DebugCommandHandler::execCommand( char * data, Entity::Player& player
 // Definition of the commands
 ///////////////////////////////////////////////////////////////////////////////////////
 
-void Core::DebugCommandHandler::scriptReload( char * data, Entity::Player& player,
-                                              boost::shared_ptr< DebugCommand > command )
-{
-   g_scriptMgr.reload();
-   player.sendDebug( "Scripts reloaded." );
-}
-
 void Core::DebugCommandHandler::help( char* data, Entity::Player& player, boost::shared_ptr< DebugCommand > command )
 {
    player.sendDebug( "Registered debug commands:" );
@@ -519,5 +514,102 @@ void Core::DebugCommandHandler::serverInfo( char * data, Entity::Player& player,
 
 void Core::DebugCommandHandler::unlockCharacter( char* data, Entity::Player& player, boost::shared_ptr< DebugCommand > command )
 {
-   player.unlock( );
+   player.unlock();
+}
+
+void Core::DebugCommandHandler::script( char* data, Entity::Player &player, boost::shared_ptr< DebugCommand > command )
+{
+   std::string subCommand;
+   std::string params = "";
+
+   // check if the command has parameters
+   std::string tmpCommand = std::string( data + command->getName().length() + 1 );
+
+   std::size_t pos = tmpCommand.find_first_of( " " );
+
+   if( pos != std::string::npos )
+      // command has parameters, grab the first part
+      subCommand = tmpCommand.substr( 0, pos );
+   else
+      // no subcommand given
+      subCommand = tmpCommand;
+
+   // todo: fix params so it's empty if there's no params
+   if( command->getName().length() + 1 + pos + 1 < strlen( data ) )
+      params = std::string( data + command->getName().length() + 1 + pos + 1 );
+
+   g_log.debug( "[" + std::to_string( player.getId() ) + "] " +
+                "subCommand " + subCommand + " params: " + params );
+
+   if( subCommand == "unload" )
+   {
+      if ( subCommand == params )
+         player.sendDebug( "Command failed: requires name of script" );
+      else
+         if( g_scriptMgr.getNativeScriptHandler().unloadScript( params ) )
+            player.sendDebug( "Unloaded script successfully." );
+         else
+            player.sendDebug( "Failed to unload script: " + params );
+   }
+   else if( subCommand == "find" || subCommand == "f" )
+   {
+      if( subCommand == params )
+         player.sendDebug( "Because reasons of filling chat with nonsense, please enter a search term" );
+      else
+      {
+         std::set< Core::Scripting::ScriptInfo* > scripts;
+         g_scriptMgr.getNativeScriptHandler().findScripts( scripts, params );
+
+         if( !scripts.empty() )
+         {
+            player.sendDebug( "Found " + std::to_string( scripts.size() ) + " scripts" );
+
+            for( auto it = scripts.begin(); it != scripts.end(); ++it )
+            {
+               auto script = *it;
+               player.sendDebug( " - '" + script->script_name + "' loaded at @ 0x" +
+                                 boost::str( boost::format( "%|X|" ) % script->handle ) +
+                                 ", script ptr: 0x" + boost::str( boost::format( "%|X|" ) % script->script ) );
+            }
+         }
+         else
+            player.sendDebug( "No scripts found with search term: " + params );
+      }
+   }
+   else if( subCommand == "load" || subCommand == "l" )
+   {
+      if( subCommand == params )
+         player.sendDebug( "Command failed: requires relative path to script" );
+      else
+      {
+         if ( g_scriptMgr.getNativeScriptHandler().loadScript( params ) )
+            player.sendDebug( "Loaded '" + params + "' successfully" );
+         else
+            player.sendDebug( "Failed to load '" + params + "'" );
+      }
+
+   }
+   else if( subCommand == "reload" || subCommand == "rl" )
+   {
+      if( subCommand == params )
+         player.sendDebug( "Command failed: requires name of script to reload" );
+      else
+         if( g_scriptMgr.getNativeScriptHandler().reloadScript( params ) )
+            player.sendDebug( "Reloaded '" + params + "' successfully" );
+         else
+            player.sendDebug( "Failed to reload '" + params + "'" );
+   }
+   else if( subCommand == "build" || subCommand == "b" )
+   {
+      if( subCommand == params )
+         player.sendDebug( "Command failed: requires name of cmake target" );
+      else
+      {
+
+      }
+   }
+   else
+   {
+      player.sendDebug( "Unknown script subcommand: " + subCommand );
+   }
 }
diff --git a/src/servers/Server_Zone/DebugCommand/DebugCommandHandler.h b/src/servers/Server_Zone/DebugCommand/DebugCommandHandler.h
index fb30cc99..4da90f29 100644
--- a/src/servers/Server_Zone/DebugCommand/DebugCommandHandler.h
+++ b/src/servers/Server_Zone/DebugCommand/DebugCommandHandler.h
@@ -35,7 +35,6 @@ public:
    void get( char * data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
    void add( char * data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
    //void debug( char * data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
-   void scriptReload( char * data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
 
    void injectPacket( char * data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
    void injectChatPacket( char * data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
@@ -43,7 +42,8 @@ public:
    void serverInfo( char * data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
 
    void unlockCharacter( char* data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
-   void targetInfo( char* data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
+
+   void script( char* data, Entity::Player& player, boost::shared_ptr< DebugCommand > command );
 
 };
 
diff --git a/src/servers/Server_Zone/Forwards.h b/src/servers/Server_Zone/Forwards.h
index 2eaaa75e..8dc06545 100644
--- a/src/servers/Server_Zone/Forwards.h
+++ b/src/servers/Server_Zone/Forwards.h
@@ -70,6 +70,7 @@ namespace Core
 
    namespace Scripting
    {
+      class NativeScriptManager;
       typedef std::function< void( Entity::Player&, uint32_t, uint16_t, uint16_t, uint16_t ) > EventReturnCallback;
    }
 
diff --git a/src/servers/Server_Zone/Script/NativeScriptApi.h b/src/servers/Server_Zone/Script/NativeScriptApi.h
new file mode 100644
index 00000000..cf3d4eb2
--- /dev/null
+++ b/src/servers/Server_Zone/Script/NativeScriptApi.h
@@ -0,0 +1,132 @@
+#ifndef NATIVE_SCRIPT_API
+#define NATIVE_SCRIPT_API
+
+#include <string>
+#include <Actor/Actor.h>
+#include <Actor/Player.h>
+#include <StatusEffect/StatusEffect.h>
+
+#ifdef _MSC_VER
+#define EXPORT __declspec( dllexport )
+#else
+#define EXPORT __attribute__((visibility("default")))
+#endif
+
+#define EXPORT_SCRIPTOBJECT( type ) \
+extern "C" EXPORT ScriptObject* getScript() \
+{ return static_cast< ScriptObject* >( new type ); }
+
+using namespace Core;
+
+// constant script ids for certain events
+#define EVENTSCRIPT_AETHERYTE_ID 0x50000
+#define EVENTSCRIPT_AETHERNET_ID 0x50001
+
+enum ScriptType
+{
+    StatusEffect,
+    Action,
+    Quest,
+    BattleNpc,
+    Zone
+};
+
+class ScriptObject
+{
+protected:
+   std::string m_scriptName;
+   uint32_t m_id;
+   ScriptType m_type;
+
+public:
+   ScriptObject( std::string name, uint32_t id, ScriptType type ) :
+      m_scriptName( name ),
+      m_id( id ),
+      m_type( type )
+   { }
+
+   virtual const std::string& getName() const
+   {
+      return m_scriptName;
+   }
+
+   virtual uint32_t getId() const
+   {
+      return m_id;
+   }
+
+   virtual ScriptType getType() const
+   {
+      return m_type;
+   }
+};
+
+
+class StatusEffectScript : public ScriptObject
+{
+public:
+   StatusEffectScript( std::string name, uint32_t effectId ) :
+      ScriptObject( name, effectId, ScriptType::StatusEffect )
+   { }
+
+   virtual void onTick( Entity::Actor& actor ) { }
+   virtual void onApply( Entity::Actor& actor ) { }
+   virtual void onRemove( Entity::Actor& actor ) { }
+   virtual void onExpire( Entity::Actor& actor ) { }
+   virtual void onPlayerCollision( Entity::Actor& actor, Entity::Actor& actorHit ) { }
+   virtual void onPlayerFinishCast( Entity::Actor& actor ) { }
+   virtual void onPlayerDamaged( Entity::Actor& actor ) { }
+   virtual void onPlayerDeath( Entity::Actor& actor ) { }
+};
+
+
+class ActionScript : public ScriptObject
+{
+public:
+    ActionScript( std::string name, uint32_t abilityId ) :
+      ScriptObject( name, abilityId, ScriptType::Action )
+   { }
+
+   virtual void onStart( Entity::Actor& sourceActor, Entity::Actor& targetActor ) { }
+   virtual void onCastFinish( Entity::Player& player, Entity::Actor& targetActor ) { }
+   virtual void onInterrupt( Entity::Actor& sourceActor/*, Core::Entity::Actor targetActor*/ ) { }
+};
+
+
+class EventScript : public ScriptObject
+{
+public:
+   EventScript( std::string name, uint32_t questId ) :
+      ScriptObject( name, questId, ScriptType::Quest )
+   { }
+
+   virtual void onTalk( uint32_t eventId, Entity::Player& player, uint64_t actorId ) { }
+   virtual void onNpcKill( uint32_t npcId, Entity::Player& player ) { }
+   virtual void onEmote( uint64_t actorId, uint32_t eventId, uint32_t emoteId, Entity::Player& player ) { }
+   virtual void onEnterZone( Entity::Player& player, uint32_t eventId, uint16_t param1, uint16_t param2 ) { }
+   virtual void onWithinRange( Entity::Player& player, uint32_t eventId, uint32_t param1, float x, float y, float z ) { }
+   virtual void onOutsideRange( Entity::Player& player, uint32_t eventId, uint32_t param1, float x, float y, float z ) { }
+   virtual void onEventItem( Entity::Player& player, uint32_t eventItemId, uint32_t eventId, uint32_t castTime, uint64_t targetId ) { }
+   virtual void onEventHandlerTradeReturn( Entity::Player& player, uint32_t eventId, uint16_t subEvent, uint16_t param, uint32_t catalogId ) { }
+};
+
+
+class BattleNpcScript : public ScriptObject
+{
+public:
+   BattleNpcScript( std::string name, uint32_t npcId ) :
+      ScriptObject( name, npcId, ScriptType::BattleNpc )
+   { }
+};
+
+class ZoneScript : public ScriptObject
+{
+public:
+   ZoneScript( std::string name, uint32_t zoneId ) :
+      ScriptObject( name, zoneId, ScriptType::Zone )
+   { }
+
+   virtual void onZoneInit() { }
+};
+
+#endif
\ No newline at end of file
diff --git a/src/servers/Server_Zone/Script/NativeScriptManager.cpp b/src/servers/Server_Zone/Script/NativeScriptManager.cpp
new file mode 100644
index 00000000..2441816e
--- /dev/null
+++ b/src/servers/Server_Zone/Script/NativeScriptManager.cpp
@@ -0,0 +1,167 @@
+#include "NativeScriptManager.h"
+
+namespace Core {
+   namespace Scripting {
+
+   NativeScriptManager::NativeScriptManager( )
+   { }
+
+   StatusEffectScript* NativeScriptManager::getStatusEffectScript( uint32_t statusId )
+   {
+      auto script = m_statusEffectScripts.find( statusId );
+      if( script == m_statusEffectScripts.end() )
+         return nullptr;
+
+      return script->second;
+   }
+
+   ActionScript* NativeScriptManager::getActionScript( uint32_t actionId )
+   {
+      auto script = m_actionScripts.find( actionId );
+      if( script == m_actionScripts.end() )
+         return nullptr;
+
+      return script->second;
+   }
+
+   EventScript* NativeScriptManager::getEventScript( uint32_t questId )
+   {
+      auto script = m_eventScripts.find( questId );
+      if( script == m_eventScripts.end() )
+         return nullptr;
+
+      return script->second;
+   }
+
+   BattleNpcScript* NativeScriptManager::getBattleNpcScript( uint32_t npcId )
+   {
+      auto script = m_battleNpcScripts.find( npcId );
+      if( script == m_battleNpcScripts.end() )
+         return nullptr;
+
+      return script->second;
+   }
+
+   ZoneScript* NativeScriptManager::getZoneScript( uint32_t zoneId )
+   {
+      auto script = m_zoneScripts.find( zoneId );
+      if( script == m_zoneScripts.end() )
+         return nullptr;
+
+      return script->second;
+   }
+
+   bool NativeScriptManager::loadScript( const std::string& path )
+   {
+      auto module = m_loader.loadModule( path );
+      if( !module )
+         return false;
+
+      auto script = m_loader.getScriptObject( module->handle );
+      if( !script )
+      {
+         m_loader.unloadScript( module );
+         return false;
+      }
+
+      module->script = script;
+      module->script_name = script->getName();
+      module->type = script->getType();
+
+      switch( script->getType() )
+      {
+         case ScriptType::StatusEffect:
+            m_statusEffectScripts[ script->getId() ] = dynamic_cast< StatusEffectScript* >( script );
+            break;
+         case ScriptType::Action:
+            m_actionScripts[ script->getId() ] = dynamic_cast< ActionScript* >( script );
+            break;
+         case ScriptType::Quest:
+            m_eventScripts[ script->getId() ] = dynamic_cast< EventScript* >( script );
+            break;
+         case ScriptType::BattleNpc:
+            m_battleNpcScripts[ script->getId() ] = dynamic_cast< BattleNpcScript* >( script );
+            break;
+         case ScriptType::Zone:
+            m_zoneScripts[ script->getId() ] = dynamic_cast< ZoneScript* >( script );
+            break;
+
+         default:
+            m_loader.unloadScript( module );
+            return false;
+      }
+
+      return true;
+   }
+
+   const std::string NativeScriptManager::getModuleExtension()
+   {
+      return m_loader.getModuleExtension();
+   }
+
+   bool NativeScriptManager::unloadScript( const std::string& name )
+   {
+      auto info = m_loader.getScriptInfo( name );
+      if( !info )
+         return false;
+
+      return unloadScript( info );
+   }
+
+   bool NativeScriptManager::unloadScript( ScriptInfo* info )
+   {
+      auto ptr = info->script;
+
+      switch( info->type )
+      {
+         case ScriptType::StatusEffect:
+            removeValueFromMap< uint32_t, StatusEffectScript* >( ptr, m_statusEffectScripts );
+            break;
+         case ScriptType::Action:
+            removeValueFromMap< uint32_t, ActionScript* >( ptr, m_actionScripts );
+            break;
+         case ScriptType::Quest:
+            removeValueFromMap< uint32_t, EventScript* >( ptr, m_eventScripts );
+            break;
+         case ScriptType::BattleNpc:
+            removeValueFromMap< uint32_t, BattleNpcScript* >( ptr, m_battleNpcScripts );
+            break;
+         case ScriptType::Zone:
+            removeValueFromMap< uint32_t, ZoneScript* >( ptr, m_zoneScripts );
+            break;
+
+         default:
+            return false;
+      }
+
+      return m_loader.unloadScript( info );
+   }
+
+   bool NativeScriptManager::reloadScript( const std::string& name )
+   {
+      auto info = m_loader.getScriptInfo( name );
+      if( !info )
+         return false;
+
+      // backup actual lib path
+      std::string libPath( info->library_path );
+
+      if( !unloadScript( info ) )
+         return false;
+
+      return loadScript( libPath );
+   }
+
+   void NativeScriptManager::findScripts( std::set< Core::Scripting::ScriptInfo* >& scripts, const std::string& search )
+   {
+      return m_loader.findScripts( scripts, search );
+   }
+
+
+
+   boost::shared_ptr< NativeScriptManager > createNativeScriptMgr()
+   {
+      return boost::make_shared< NativeScriptManager >();
+   }
+}
+}
diff --git a/src/servers/Server_Zone/Script/NativeScriptManager.h b/src/servers/Server_Zone/Script/NativeScriptManager.h
new file mode 100644
index 00000000..42c4a4ed
--- /dev/null
+++ b/src/servers/Server_Zone/Script/NativeScriptManager.h
@@ -0,0 +1,69 @@
+#ifndef NATIVE_SCRIPT_H
+#define NATIVE_SCRIPT_H
+
+#include <unordered_map>
+#include <set>
+
+#include <boost/shared_ptr.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/filesystem.hpp>
+
+#include <Server_Common/Crypt/md5.h>
+
+#include "ScriptLoader.h"
+
+namespace Core {
+namespace Scripting {
+
+   class NativeScriptManager
+   {
+   protected:
+      std::unordered_map< uint32_t, StatusEffectScript* > m_statusEffectScripts;
+      std::unordered_map< uint32_t, ActionScript* > m_actionScripts;
+      std::unordered_map< uint32_t, EventScript* > m_eventScripts;
+      std::unordered_map< uint32_t, BattleNpcScript* > m_battleNpcScripts;
+      std::unordered_map< uint32_t, ZoneScript* > m_zoneScripts;
+
+      ScriptLoader m_loader;
+
+      bool unloadScript( ScriptInfo* info );
+
+   public:
+      NativeScriptManager( );
+
+      StatusEffectScript* getStatusEffectScript( uint32_t statusId );
+      ActionScript* getActionScript( uint32_t actionId );
+      EventScript* getEventScript( uint32_t questId );
+      BattleNpcScript* getBattleNpcScript( uint32_t npcId );
+      ZoneScript* getZoneScript( uint32_t zoneId );
+
+      bool loadScript( const std::string& path );
+      bool unloadScript( const std::string& name );
+      bool reloadScript( const std::string& name );
+      void findScripts( std::set< Core::Scripting::ScriptInfo* >& scripts, const std::string& search );
+
+      const std::string getModuleExtension();
+
+      template< typename key, typename val >
+      bool removeValueFromMap( ScriptObject* ptr, std::unordered_map< key, val >& map )
+      {
+         for( typename std::unordered_map< key, val >::iterator it = map.begin(); it != map.end(); ++it )
+         {
+            if( ptr == static_cast< ScriptObject* >( it->second ) )
+            {
+               map.erase( it );
+               return true;
+            }
+         }
+
+         return false;
+      }
+   };
+
+
+
+   boost::shared_ptr< NativeScriptManager > createNativeScriptMgr();
+} }
+
+
+#endif
\ No newline at end of file
diff --git a/src/servers/Server_Zone/Script/ScriptInfo.h b/src/servers/Server_Zone/Script/ScriptInfo.h
new file mode 100644
index 00000000..19945723
--- /dev/null
+++ b/src/servers/Server_Zone/Script/ScriptInfo.h
@@ -0,0 +1,34 @@
+#ifndef SAPPHIRE_SCRIPTINFO_H
+#define SAPPHIRE_SCRIPTINFO_H
+
+#include "NativeScriptApi.h"
+
+#ifdef _WIN32
+#include <windows.h>
+typedef HMODULE ModuleHandle;
+#else
+typedef void* ModuleHandle;
+#endif
+
+namespace Core {
+namespace Scripting {
+
+   class ScriptInfo
+   {
+   public:
+      ScriptInfo() = default;
+
+      std::string library_name;
+      std::string cache_path;
+      std::string library_path;
+
+      std::string script_name;
+      ModuleHandle handle;
+      ScriptObject* script;
+      ScriptType type;
+   };
+}
+}
+
+
+#endif //SAPPHIRE_SCRIPTINFO_H
diff --git a/src/servers/Server_Zone/Script/ScriptLoader.cpp b/src/servers/Server_Zone/Script/ScriptLoader.cpp
new file mode 100644
index 00000000..7900a91e
--- /dev/null
+++ b/src/servers/Server_Zone/Script/ScriptLoader.cpp
@@ -0,0 +1,187 @@
+#include "ScriptLoader.h"
+
+#include <Server_Common/Logging/Logger.h>
+#include <Server_Common/Config/XMLConfig.h>
+#include "ServerZone.h"
+
+#include <boost/format.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/filesystem.hpp>
+
+extern Core::Logger g_log;
+extern Core::ServerZone g_serverZone;
+
+namespace fs = boost::filesystem;
+
+Core::Scripting::ScriptLoader::ScriptLoader()
+{}
+
+const std::string Core::Scripting::ScriptLoader::getModuleExtension()
+{
+#ifdef _WIN32
+   return ".dll";
+#elif __APPLE__
+   return ".dylib";
+#else
+   return ".so";
+#endif
+}
+
+bool Core::Scripting::ScriptLoader::unloadModule( ModuleHandle handle )
+{
+#ifdef _WIN32
+   bool success = FreeLibrary( handle ) != 0;
+#else
+   bool success = dlclose( handle ) == 0;
+#endif
+
+   if( !success )
+   {
+      g_log.error( "Failed to unload module @ 0x" + boost::str( boost::format( "%|08X|" ) % handle ) );
+
+      return false;
+   }
+
+   g_log.debug( "Unloaded module @ 0x" + boost::str( boost::format( "%|08X|" ) % handle ) );
+
+   return true;
+}
+
+Core::Scripting::ScriptInfo* Core::Scripting::ScriptLoader::loadModule( const std::string& path )
+{
+   fs::path f( path );
+
+   if ( isModuleLoaded( f.stem().string() ) )
+   {
+      g_log.error( "Unable to load module '" + f.stem().string() + "' as it is already loaded" );
+      return nullptr;
+   }
+
+   // copy to temp dir
+   fs::path cacheDir( f.parent_path() /= g_serverZone.getConfig()->getValue< std::string >( "Settings.General.Scripts.CachePath", "./cache/" ) );
+   fs::create_directories( cacheDir );
+   fs::path dest( cacheDir /= f.filename().string() );
+
+   if ( fs::exists( dest ) )
+   {
+      fs::remove( dest );
+   }
+
+   fs::copy_file( f, dest );
+
+#ifdef _WIN32
+   ModuleHandle handle = LoadLibrary( dest.string().c_str() );
+#else
+   ModuleHandle handle = dlopen( dest.string().c_str(), RTLD_LAZY );
+#endif
+
+   if( !handle )
+   {
+      g_log.error( "Failed to load module from: " + path );
+
+      return nullptr;
+   }
+
+   g_log.info( "Loaded module '" + f.filename().string() + "' @ 0x" + boost::str( boost::format( "%|08X|" ) % handle ) );
+
+   auto info = new ScriptInfo;
+   info->handle = handle;
+   info->library_name = f.stem().string();
+   info->cache_path = dest.string();
+   info->library_path = f.string();
+
+   m_scriptMap.insert( std::make_pair( f.stem().string(), info ) );
+
+   return info;
+}
+
+ScriptObject* Core::Scripting::ScriptLoader::getScriptObject( ModuleHandle handle )
+{
+   using getScript = ScriptObject*(*)();
+
+#ifdef _WIN32
+   getScript func = reinterpret_cast< getScript >( GetProcAddress( handle, "getScript" ) );
+#else
+   getScript func = reinterpret_cast< getScript >( dlsym( handle, "getScript" ) );
+#endif
+
+   if( func )
+   {
+      auto ptr = func();
+
+      g_log.debug( "got ScriptObject @ 0x" + boost::str( boost::format( "%|08X|" ) % ptr ) );
+      g_log.debug( "script info -> name: " + std::string( ptr->getName() ) + ", id: " + std::to_string( ptr->getId() ) );
+
+      return ptr;
+   }
+   else
+      return nullptr;
+}
+
+bool Core::Scripting::ScriptLoader::unloadScript( Core::Scripting::ScriptInfo* info )
+{
+   return unloadScript( info->handle );
+}
+
+bool Core::Scripting::ScriptLoader::unloadScript( ModuleHandle handle )
+{
+   for( auto it = m_scriptMap.begin(); it != m_scriptMap.end(); ++it )
+   {
+      if( it->second->handle == handle )
+      {
+         auto info = it->second;
+         m_scriptMap.erase( it );
+
+         if( unloadModule( handle ) )
+         {
+            // remove cached file
+            fs::remove( info->cache_path );
+
+            delete info;
+
+            return true;
+         }
+
+         g_log.error( "failed to unload module: " + info->library_name );
+
+         return false;
+      }
+   }
+
+   return false;
+}
+
+bool Core::Scripting::ScriptLoader::isModuleLoaded( std::string name )
+{
+   for( auto it = m_scriptMap.begin(); it != m_scriptMap.end(); ++it )
+   {
+      if( boost::iequals( it->second->library_name, name ) )
+         return true;
+   }
+
+   return false;
+}
+
+Core::Scripting::ScriptInfo* Core::Scripting::ScriptLoader::getScriptInfo( std::string name )
+{
+   for( auto it = m_scriptMap.begin(); it != m_scriptMap.end(); ++it )
+   {
+      if( it->second->script_name == name )
+      {
+         return it->second;
+      }
+   }
+
+   return nullptr;
+}
+
+void Core::Scripting::ScriptLoader::findScripts( std::set< Core::Scripting::ScriptInfo* >& scripts, const std::string& search )
+{
+   for( auto it = m_scriptMap.begin(); it != m_scriptMap.end(); ++it )
+   {
+      if( it->second->script_name.find( search ) != std::string::npos )
+      {
+         scripts.insert( it->second );
+      }
+   }
+}
\ No newline at end of file
diff --git a/src/servers/Server_Zone/Script/ScriptLoader.h b/src/servers/Server_Zone/Script/ScriptLoader.h
new file mode 100644
index 00000000..0f452d19
--- /dev/null
+++ b/src/servers/Server_Zone/Script/ScriptLoader.h
@@ -0,0 +1,48 @@
+#ifndef SAPPHIRE_SCRIPTLOADER_H
+#define SAPPHIRE_SCRIPTLOADER_H
+
+#include <string>
+#include <unordered_map>
+#include <set>
+
+#include "NativeScriptApi.h"
+#include "ScriptInfo.h"
+
+#ifdef _WIN32
+#include <windows.h>
+typedef HMODULE ModuleHandle;
+#else
+#include <dlfcn.h>
+typedef void* ModuleHandle;
+#endif
+
+namespace Core {
+namespace Scripting {
+
+   class ScriptLoader {
+   protected:
+       std::unordered_map< std::string, ScriptInfo* > m_scriptMap;
+
+       bool unloadModule( ModuleHandle );
+
+   public:
+       ScriptLoader();
+
+       const std::string getModuleExtension();
+       ScriptInfo* loadModule( const std::string& );
+       bool unloadScript( ScriptInfo* );
+       bool unloadScript( ModuleHandle );
+       ScriptInfo* getScriptInfo( std::string name );
+       ScriptObject* getScriptObject( ModuleHandle handle );
+       bool isModuleLoaded( std::string name );
+
+       void findScripts( std::set< Core::Scripting::ScriptInfo* >& scripts, const std::string& search );
+   };
+
+}
+}
+
+
+
+
+#endif //SAPPHIRE_SCRIPTLOADER_H
diff --git a/src/servers/Server_Zone/Script/ScriptManager.cpp b/src/servers/Server_Zone/Script/ScriptManager.cpp
index 7ee72a52..2680618e 100644
--- a/src/servers/Server_Zone/Script/ScriptManager.cpp
+++ b/src/servers/Server_Zone/Script/ScriptManager.cpp
@@ -1,8 +1,7 @@
 #include <Server_Common/Logging/Logger.h>
 #include <Server_Common/Exd/ExdData.h>
-#include <chaiscript/chaiscript.hpp>
 
-#include <Server_Common/Script/ChaiscriptStdLib.h>
+#include "NativeScriptManager.h"
 
 #include "Zone/Zone.h"
 #include "Actor/Player.h"
@@ -20,13 +19,15 @@
 #include <boost/format.hpp>
 #include <boost/foreach.hpp>
 
+#include <Server_Common/Config/XMLConfig.h>
+
 extern Core::Logger g_log;
 extern Core::Data::ExdData g_exdData;
 extern Core::ServerZone g_serverZone;
 
 Core::Scripting::ScriptManager::ScriptManager()
 {
-   m_pChaiHandler = create_chaiscript();
+   m_nativeScriptManager = createNativeScriptMgr();
 }
 
 Core::Scripting::ScriptManager::~ScriptManager()
@@ -34,7 +35,24 @@ Core::Scripting::ScriptManager::~ScriptManager()
 
 }
 
-void Core::Scripting::ScriptManager::loadDir( std::string dirname, std::set<std::string>& chaiFiles )
+bool Core::Scripting::ScriptManager::init()
+{
+   std::set< std::string > files;
+
+   loadDir( g_serverZone.getConfig()->getValue< std::string >( "Settings.General.Scripts.Path", "./compiledscripts/" ),
+            files, m_nativeScriptManager->getModuleExtension() );
+
+   for( auto itr = files.begin(); itr != files.end(); ++itr )
+   {
+      auto& path = *itr;
+
+      m_nativeScriptManager->loadScript( path );
+   }
+
+   return true;
+}
+
+void Core::Scripting::ScriptManager::loadDir( std::string dirname, std::set<std::string>& files, std::string ext )
 {
 
    g_log.info( "ScriptEngine: loading scripts from " + dirname );
@@ -45,11 +63,9 @@ void Core::Scripting::ScriptManager::loadDir( std::string dirname, std::set<std:
 
    BOOST_FOREACH( boost::filesystem::path const& i, make_pair( iter, eod ) )
    {
-
-      if( is_regular_file( i ) && boost::filesystem::extension( i.string() ) == ".chai" ||
-          boost::filesystem::extension( i.string() ) == ".inc" )
+      if( is_regular_file( i ) && boost::filesystem::extension( i.string() ) == ext )
       {
-         chaiFiles.insert( i.string() );
+         files.insert( i.string() );
       }
    }
 
@@ -57,15 +73,15 @@ void Core::Scripting::ScriptManager::loadDir( std::string dirname, std::set<std:
 
 void Core::Scripting::ScriptManager::onPlayerFirstEnterWorld( Entity::Player& player )
 {
-   try
-   {
-      std::string test = m_onFirstEnterWorld( player );
-   }
-   catch( const std::exception &e )
-   {
-      std::string what = e.what();
-      g_log.Log( LoggingSeverity::error, what );
-   }
+//   try
+//   {
+//      std::string test = m_onFirstEnterWorld( player );
+//   }
+//   catch( const std::exception &e )
+//   {
+//      std::string what = e.what();
+//      g_log.Log( LoggingSeverity::error, what );
+//   }
 }
 
 bool Core::Scripting::ScriptManager::registerBnpcTemplate( std::string templateName, uint32_t bnpcBaseId,
@@ -74,19 +90,6 @@ bool Core::Scripting::ScriptManager::registerBnpcTemplate( std::string templateN
    return g_serverZone.registerBnpcTemplate( templateName, bnpcBaseId, bnpcNameId, modelId, aiName );
 }
 
-void Core::Scripting::ScriptManager::reload()
-{
-   auto handler = create_chaiscript();
-   m_pChaiHandler.swap( handler );
-   init();
-}
-
-const boost::shared_ptr< chaiscript::ChaiScript >& Core::Scripting::ScriptManager::getHandler() const
-{
-   return m_pChaiHandler;
-}
-
-
 bool Core::Scripting::ScriptManager::onTalk( Entity::Player& player, uint64_t actorId, uint32_t eventId )
 {
    std::string eventName = "onTalk";
@@ -101,24 +104,134 @@ bool Core::Scripting::ScriptManager::onTalk( Entity::Player& player, uint64_t ac
                                           % static_cast< uint64_t >( eventId & 0xFFFFFFF ) ) + ")" );
 
    uint16_t eventType = eventId >> 16;
+   uint32_t scriptId = eventId;
 
-   try
+   // aethernet/aetherytes need to be handled separately
+   if( eventType == Common::EventType::Aetheryte )
+   {
+      auto aetherInfo = g_exdData.getAetheryteInfo( eventId & 0xFFFF );
+      scriptId = EVENTSCRIPT_AETHERYTE_ID;
+      if( !aetherInfo->isAetheryte )
+         scriptId = EVENTSCRIPT_AETHERNET_ID;
+   }
+
+   auto script = m_nativeScriptManager->getEventScript( scriptId );
+   if( script )
    {
-      // Get object from engine
-      auto obj = m_pChaiHandler->eval( objName );
       player.sendDebug( "Calling: " + objName + "." + eventName );
 
       player.eventStart( actorId, eventId, Event::Event::Talk, 0, 0 );
 
-      auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &,
-                                                           uint32_t, Entity::Player&, uint64_t ) > >( eventName );
-      fn( obj, eventId, player, actorId );
+      script->onTalk( eventId, player, actorId );
 
       player.checkEvent( eventId );
    }
-   catch( std::exception& e )
+   else
    {
-      player.sendDebug( e.what( ) );
+      if ( eventType == Common::EventType::Quest )
+      {
+         auto questInfo = g_exdData.getQuestInfo( eventId );
+         if ( questInfo )
+         {
+            player.sendUrgent( "Quest not implemented: " + questInfo->name );
+
+         }
+      }
+
+      return false;
+   }
+
+   return true;
+}
+
+bool Core::Scripting::ScriptManager::onEnterTerritory( Entity::Player& player, uint32_t eventId,
+                                                       uint16_t param1, uint16_t param2 )
+{
+   std::string eventName = "onEnterTerritory";
+   std::string objName = Event::getEventName( eventId );
+
+   player.sendDebug( "Calling: " + objName + "." + eventName + " - " + std::to_string( eventId ) );
+
+   auto script = m_nativeScriptManager->getEventScript( eventId );
+   if( script )
+   {
+      player.eventStart( player.getId(), eventId, Event::Event::EnterTerritory, 0, player.getZoneId() );
+
+      script->onEnterZone( player, eventId, param1, param2 );
+
+      player.checkEvent( eventId );
+
+      return true;
+   }
+
+   return false;
+}
+
+bool Core::Scripting::ScriptManager::onWithinRange( Entity::Player& player, uint32_t eventId, uint32_t param1,
+                                                    float x, float y, float z )
+{
+
+   std::string eventName = "onWithinRange";
+   std::string objName = Event::getEventName( eventId );
+   player.sendDebug( "Calling: " + objName + "." + eventName + " - " + std::to_string( eventId ) + " p1: " + std::to_string( param1 ) );
+
+   auto script = m_nativeScriptManager->getEventScript( eventId );
+   if( script )
+   {
+      player.eventStart( player.getId(), eventId, Event::Event::WithinRange, 1, param1 );
+
+      script->onWithinRange( player, eventId, param1, x, y, z );
+
+      player.checkEvent( eventId );
+
+      return true;
+   }
+
+   return false;
+}
+
+bool Core::Scripting::ScriptManager::onOutsideRange( Entity::Player& player, uint32_t eventId, uint32_t param1,
+                                                     float x, float y, float z )
+{
+   std::string eventName = "onOutsideRange";
+   std::string objName = Event::getEventName( eventId );
+   player.sendDebug( "Calling: " + objName + "." + eventName + " - " + std::to_string( eventId ) );
+
+   auto script = m_nativeScriptManager->getEventScript( eventId );
+   if( script )
+   {
+      player.eventStart( player.getId(), eventId, Event::Event::WithinRange, 1, param1 );
+
+      script->onOutsideRange( player, eventId, param1, x, y, z );
+
+      player.checkEvent( eventId );
+
+      return true;
+   }
+
+   return false;
+}
+
+bool Core::Scripting::ScriptManager::onEmote( Entity::Player& player, uint64_t actorId,
+                                              uint32_t eventId, uint8_t emoteId )
+{
+   std::string eventName = "onEmote";
+   std::string objName = Event::getEventName( eventId );
+
+   auto script = m_nativeScriptManager->getEventScript( eventId );
+   if( script )
+   {
+      player.sendDebug( "Calling: " + objName + "." + eventName );
+
+      player.eventStart( actorId, eventId, Event::Event::Emote, 0, emoteId );
+
+      script->onEmote( actorId, eventId, emoteId, player );
+
+      player.checkEvent( eventId );
+   }
+   else
+   {
+      uint16_t eventType = eventId >> 16;
 
       if( eventType == Common::EventType::Quest )
       {
@@ -129,134 +242,9 @@ bool Core::Scripting::ScriptManager::onTalk( Entity::Player& player, uint64_t ac
             return false;
          }
       }
-
       return false;
    }
-   return true;
-}
 
-bool Core::Scripting::ScriptManager::onEnterTerritory( Entity::Player& player, uint32_t eventId,
-                                                       uint16_t param1, uint16_t param2 )
-{
-   std::string eventName = "onEnterTerritory";
-   std::string objName = Event::getEventName( eventId );
-
-   try
-   {
-      // Get object from engine
-      auto obj = m_pChaiHandler->eval( objName );
-
-      player.sendDebug( "Calling: " + objName + "." + eventName );
-
-      player.eventStart( player.getId(), eventId, Event::Event::EnterTerritory, 0, player.getZoneId() );
-
-      auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, uint32_t,
-                                                           Entity::Player&, uint16_t, uint16_t ) > >( eventName );
-      fn( obj, eventId, player, param1, param2 );
-
-      player.checkEvent( eventId );
-   }
-   catch( std::exception& e )
-   {
-      player.sendDebug( e.what() );
-      return false;
-   }
-   return true;
-}
-
-bool Core::Scripting::ScriptManager::onWithinRange( Entity::Player& player, uint32_t eventId, uint32_t param1,
-                                                    float x, float y, float z )
-{
-   std::string eventName = "onWithinRange";
-   std::string objName = Event::getEventName( eventId );
-
-   try
-   {
-      // Get object from engine
-      auto obj = m_pChaiHandler->eval( Event::getEventName( eventId )  );
-
-      player.sendDebug( "Calling: " + objName + "." + eventName );
-
-      player.eventStart( player.getId(), eventId, Event::Event::WithinRange, 1, param1 );
-
-      auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, uint32_t, Entity::Player&, uint32_t,
-                                                           float, float, float ) > >( eventName );
-      fn( obj, eventId, player, param1, x, y, z );
-
-      player.checkEvent( eventId );
-   }
-   catch( std::exception& e )
-   {
-      player.sendDebug( e.what() );
-      return false;
-   }
-   return true;
-}
-
-bool Core::Scripting::ScriptManager::onOutsideRange( Entity::Player& player, uint32_t eventId, uint32_t param1,
-                                                     float x, float y, float z )
-{
-   std::string eventName = "onOutsideRange";
-   std::string objName = Event::getEventName( eventId );
-
-   try
-   {
-      // Get object from engine
-      auto obj = m_pChaiHandler->eval( Event::getEventName( eventId ) );
-
-      player.sendDebug( "Calling: " + objName + "." + eventName );
-
-      player.eventStart( player.getId(), eventId, Event::Event::OutsideRange, 1, param1 );
-
-      auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, uint32_t, Entity::Player&, uint32_t,
-                                                           float, float, float ) > >( eventName );
-      fn( obj, eventId, player, param1, x, y, z );
-
-      player.checkEvent( eventId );
-   }
-   catch( std::exception& e )
-   {
-      player.sendDebug( e.what() );
-      return false;
-   }
-   return true;
-}
-
-bool Core::Scripting::ScriptManager::onEmote( Entity::Player& player, uint64_t actorId,
-                                              uint32_t eventId, uint8_t emoteId )
-{
-   std::string eventName = "onEmote";
-   std::string objName = Event::getEventName( eventId );
-
-   try
-   {
-      auto obj = m_pChaiHandler->eval( Event::getEventName( eventId ) );
-
-      player.sendDebug( "Calling: " + objName + "." + eventName );
-
-      player.eventStart( actorId, eventId, Event::Event::Emote, 0, emoteId );
-
-      auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, uint32_t, Entity::Player&,
-                                                           uint64_t, uint8_t ) > >( eventName );
-      fn( obj, eventId, player, actorId, emoteId );
-
-      player.checkEvent( eventId );
-   }
-   catch( std::exception& e )
-   {
-      uint16_t eventType = eventId >> 16;
-
-      if( eventType == Common::EventType::Quest )
-      {
-         auto questInfo = g_exdData.getQuestInfo( eventId );
-         if( questInfo )
-         {
-            player.sendDebug( "Quest not implemented: " + questInfo->name + "\n" + e.what() );
-            return false;
-         }
-      }
-      return false;
-   }
    return true;
 }
 
@@ -290,7 +278,7 @@ bool Core::Scripting::ScriptManager::onEventHandlerReturn( Entity::Player& playe
             else
                pEvent->setPlayedScene( false );
          }
-         // else, finish the event.
+            // else, finish the event.
          else
             player.eventFinish( eventId, 1 );
       }
@@ -307,20 +295,15 @@ bool Core::Scripting::ScriptManager::onEventHandlerReturn( Entity::Player& playe
 bool Core::Scripting::ScriptManager::onEventHandlerTradeReturn( Entity::Player& player, uint32_t eventId,
                                                                 uint16_t subEvent, uint16_t param, uint32_t catalogId )
 {
-   std::string eventName = Event::getEventName( eventId ) + "_TRADE";
+   auto script = m_nativeScriptManager->getEventScript( eventId );
+   if( script )
+   {
+      script->onEventHandlerTradeReturn( player, eventId, subEvent, param, catalogId );
 
-   try
-   {
-      auto fn = m_pChaiHandler->eval< std::function< void( Entity::Player&, uint32_t,
-                                                           uint16_t, uint16_t, uint32_t ) > >( eventName );
-      fn( player, eventId, subEvent, param, catalogId );
-   }
-   catch( ... )
-   {
-      return false;
+      return true;
    }
 
-   return true;
+   return false;
 }
 
 bool Core::Scripting::ScriptManager::onEventItem( Entity::Player& player, uint32_t eventItemId,
@@ -328,34 +311,26 @@ bool Core::Scripting::ScriptManager::onEventItem( Entity::Player& player, uint32
 {
    std::string eventName = "onEventItem";
    std::string objName = Event::getEventName( eventId );
+   player.sendDebug( "Calling: " + objName + "." + eventName + " - " + std::to_string( eventId ) );
 
-   try
+   auto script = m_nativeScriptManager->getEventScript( eventId );
+   if( script )
    {
-      auto obj = m_pChaiHandler->eval( Event::getEventName( eventId ) );
-
-      player.sendDebug( "Calling: " + objName + "." + eventName );
-
       player.eventStart( targetId, eventId, Event::Event::Item, 0, 0 );
-      
-      auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, uint32_t, Entity::Player&,
-                                                           uint32_t, uint32_t, uint64_t ) > >( eventName );
-      fn( obj, eventId, player, eventItemId, castTime, targetId );
-   }
-   catch( std::exception& e )
-   {
-      player.sendNotice( e.what() );
-      return false;
+
+      script->onEventItem( player, eventItemId, eventId, castTime, targetId );
+
+      return true;
    }
 
-   return true;
-
+   return false;
 }
 
 bool Core::Scripting::ScriptManager::onMobKill( Entity::Player& player, uint16_t nameId )
 {
    std::string eventName = "onBnpcKill_" + std::to_string( nameId );
 
-   
+
    // loop through all active quests and try to call available onMobKill callbacks
    for( size_t i = 0; i < 30; i++ )
    {
@@ -364,23 +339,15 @@ bool Core::Scripting::ScriptManager::onMobKill( Entity::Player& player, uint16_t
          continue;
 
       uint16_t questId = activeQuests->c.questId;
-      if( questId != 0 )
+
+      auto script = m_nativeScriptManager->getEventScript( questId );
+      if( script )
       {
-         auto obj = m_pChaiHandler->eval( Event::getEventName( 0x00010000 | questId ) );
          std::string objName = Event::getEventName( 0x00010000 | questId );
 
          player.sendDebug("Calling: " + objName + "." + eventName);
 
-         try
-         {
-            auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, Entity::Player& ) > >(eventName);
-            fn( obj, player );
-         }
-         catch( std::exception& e )
-         {
-            g_log.info( e.what() );
-         }
-
+         script->onNpcKill( nameId, player );
       }
    }
 
@@ -389,115 +356,76 @@ bool Core::Scripting::ScriptManager::onMobKill( Entity::Player& player, uint16_t
 
 bool Core::Scripting::ScriptManager::onCastFinish( Entity::Player& player, Entity::ActorPtr pTarget, uint32_t actionId )
 {
-    std::string eventName = "onFinish";
+   auto script = m_nativeScriptManager->getActionScript( actionId );
 
-    try 
-    {
-        auto obj = m_pChaiHandler->eval( "skillDef_" + std::to_string( actionId ) );
-        std::string objName = "skillDef_" + std::to_string( actionId );
+   if( script )
+      script->onCastFinish( player, *pTarget );
 
-        player.sendDebug( "Calling: " + objName + "." + eventName );
-        auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, Entity::Player&,
-                                                             Entity::Actor& ) > >( eventName );
-        fn( obj, player, *pTarget );
-    }
-    catch( std::exception& e )
-    {
-        player.sendUrgent( e.what() );
-    }
-
-    return true;
+   return true;
 }
 
 bool Core::Scripting::ScriptManager::onStatusReceive( Entity::ActorPtr pActor, uint32_t effectId )
 {
-   std::string eventName = "onReceive";
-
-   try
-   {
-      auto obj = m_pChaiHandler->eval( "statusDef_" + std::to_string( effectId ) );
-      std::string objName = "statusDef_" + std::to_string( effectId );
-
-      if( pActor->isPlayer() )
-         pActor->getAsPlayer()->sendDebug( "Calling: " + objName + "." + eventName );
-
-      auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, Entity::Actor&) > >( eventName );
-      fn( obj, *pActor );
-   }
-   catch( std::exception& e )
+   auto script = m_nativeScriptManager->getStatusEffectScript( effectId );
+   if( script )
    {
       if( pActor->isPlayer() )
-         pActor->getAsPlayer()->sendUrgent( e.what() );
+         pActor->getAsPlayer()->sendDebug( "Calling status receive for statusid: " + std::to_string( effectId ) );
+
+      script->onApply( *pActor );
+
+      return true;
    }
 
-   return true;
+   return false;
 }
 
 bool Core::Scripting::ScriptManager::onStatusTick( Entity::ActorPtr pActor, Core::StatusEffect::StatusEffect& effect )
 {
-   std::string eventName = "onTick";
-
-   try
-   {
-      auto obj = m_pChaiHandler->eval( "statusDef_" + std::to_string( effect.getId() ) );
-      std::string objName = "statusDef_" + std::to_string( effect.getId() );
-
-      if( pActor->isPlayer() )
-         pActor->getAsPlayer()->sendDebug( "Calling: " + objName + "." + eventName );
-
-      auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, Entity::Actor&,
-                                                           StatusEffect::StatusEffect& ) > >( eventName );
-      fn( obj, *pActor, effect );
-   }
-   catch( std::exception& e )
+   auto script = m_nativeScriptManager->getStatusEffectScript( effect.getId() );
+   if( script )
    {
       if( pActor->isPlayer() )
-         pActor->getAsPlayer()->sendUrgent( e.what() );
+         pActor->getAsPlayer()->sendDebug( "Calling status tick for statusid: " + std::to_string( effect.getId() ) );
+
+      script->onTick( *pActor );
+
+      return true;
    }
 
-   return true;
+   return false;
 }
 
 bool Core::Scripting::ScriptManager::onStatusTimeOut( Entity::ActorPtr pActor, uint32_t effectId )
 {
-   std::string eventName = "onTimeOut";
-
-   try
-   {
-      auto obj = m_pChaiHandler->eval( "statusDef_" + std::to_string( effectId ) );
-      std::string objName = "statusDef_" + std::to_string( effectId );
-
-      if( pActor->isPlayer() )
-         pActor->getAsPlayer()->sendDebug( "Calling: " + objName + "." + eventName );
-
-      auto fn = m_pChaiHandler->eval< std::function< void( chaiscript::Boxed_Value &, Entity::Actor& ) > >( eventName );
-      fn( obj, *pActor );
-   }
-   catch( std::exception& e )
+   auto script = m_nativeScriptManager->getStatusEffectScript( effectId );
+   if( script )
    {
       if( pActor->isPlayer() )
-         pActor->getAsPlayer()->sendUrgent( e.what() );
+         pActor->getAsPlayer()->sendDebug( "Calling status timeout for statusid: " + std::to_string( effectId ) );
+
+      script->onExpire( *pActor );
+
+      return true;
    }
 
-   return true;
+   return false;
 }
 
 bool Core::Scripting::ScriptManager::onZoneInit( ZonePtr pZone )
 {
-   std::string eventName = "onZoneInit_" + pZone->getInternalName();
+   auto script = m_nativeScriptManager->getZoneScript( pZone->getId() );
+   if( script )
+   {
+      script->onZoneInit();
 
-   try
-   {
-      auto fn = m_pChaiHandler->eval< std::function< void( Zone& ) > >( eventName );
-      fn( *pZone );
-   }
-   catch( std::exception& e )
-   {
-      g_log.info( e.what() );
-      return false;
+      return true;
    }
 
-   return true;
-
+   return false;
 }
 
+Scripting::NativeScriptManager& Core::Scripting::ScriptManager::getNativeScriptHandler()
+{
+   return *m_nativeScriptManager;
+}
diff --git a/src/servers/Server_Zone/Script/ScriptManager.h b/src/servers/Server_Zone/Script/ScriptManager.h
index 2e66f3cf..5df46660 100644
--- a/src/servers/Server_Zone/Script/ScriptManager.h
+++ b/src/servers/Server_Zone/Script/ScriptManager.h
@@ -8,12 +8,6 @@
 #include <Server_Common/Common.h>
 #include "Forwards.h"
 
-
-namespace chaiscript
-{
-   class ChaiScript;
-}
-
 namespace Core
 {
    namespace Scripting
@@ -23,7 +17,7 @@ namespace Core
       {
       private:
 
-         boost::shared_ptr< chaiscript::ChaiScript > m_pChaiHandler;
+          boost::shared_ptr< NativeScriptManager > m_nativeScriptManager;
 
          std::function< std::string( Entity::Player& ) > m_onFirstEnterWorld;
         // auto fn = m_pChaiHandler->eval< std::function<const std::string( Entity::Player ) > >( "onFirstEnterWorld" );
@@ -32,11 +26,9 @@ namespace Core
          ScriptManager();
          ~ScriptManager();
 
-         int32_t init();
+         bool init();
          void reload();
 
-         const boost::shared_ptr< chaiscript::ChaiScript >& getHandler() const;
-
          void onPlayerFirstEnterWorld( Entity::Player& player );
 
          static bool registerBnpcTemplate( std::string templateName, uint32_t bnpcBaseId, uint32_t bnpcNameId, uint32_t modelId, std::string aiName );
@@ -57,14 +49,14 @@ namespace Core
          bool onStatusTimeOut( Entity::ActorPtr pActor, uint32_t effectId );
 
          bool onZoneInit( ZonePtr pZone );
-         
+
          bool onEventHandlerReturn( Entity::Player& player, uint32_t eventId, uint16_t subEvent, uint16_t param1, uint16_t param2, uint16_t param3 );
          bool onEventHandlerTradeReturn( Entity::Player& player, uint32_t eventId, uint16_t subEvent, uint16_t param, uint32_t catalogId );
-         
 
-         void loadDir( std::string dirname, std::set<std::string>& chaiFiles );
 
-          
+         void loadDir( std::string dirname, std::set<std::string>& files, std::string ext );
+
+         NativeScriptManager& getNativeScriptHandler();
       };
    }
 }
diff --git a/src/servers/Server_Zone/Script/ScriptManagerInit.cpp b/src/servers/Server_Zone/Script/ScriptManagerInit.cpp
deleted file mode 100644
index dbf76194..00000000
--- a/src/servers/Server_Zone/Script/ScriptManagerInit.cpp
+++ /dev/null
@@ -1,207 +0,0 @@
-#include <chaiscript/chaiscript.hpp>
-
-#include <Server_Common/Config/XMLConfig.h>
-#include <Server_Common/Logging/Logger.h>
-#include <Server_Common/Script/ChaiscriptStdLib.h>
-
-#include "ServerZone.h"
-
-#include "Script/ScriptManager.h"
-
-#include "Zone/Zone.h"
-#include "Actor/Player.h"
-#include "Actor/BattleNpc.h"
-#include "Event/Event.h"
-#include "Event/EventHelper.h"
-#include "Network/PacketWrappers/ServerNoticePacket.h"
-#include "StatusEffect/StatusEffect.h"
-
-#include <boost/lexical_cast.hpp>
-
-extern Core::Logger g_log;
-extern Core::ServerZone g_serverZone;
-
-int Core::Scripting::ScriptManager::init()
-{
-   // ACTOR / PLAYER BINDINGS
-   /////////////////////////////////////////////////////////////////////////////////////////////
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::getName ), "getName" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::getId ), "getId" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::getHp ), "getHp" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::getMp ), "getMp" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::getTp ), "getTp" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::getLevel ), "getLevel" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::getTargetId ), "getTargetId" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::addStatusEffect ), "addStatusEffect" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::addStatusEffectById ), "addStatusEffectById" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::addStatusEffectByIdIfNotExist ), "addStatusEffectByIdIfNotExist" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Actor::takeDamage ), "takeDamage" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::forceZoneing ), "setZone" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getClassAsInt ), "getClass" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getRace ), "getRace" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getGender ), "getGender" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::gainExp ), "gainExp" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::unlock ), "unlock" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::registerAetheryte ), "aetheryteRegister" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::learnAction ), "learnAction" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getHomepoint ), "getHomepoint" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setHomepoint ), "setHomepoint" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::returnToHomepoint ), "returnToHomepoint" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::teleport ), "teleport" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::prepareZoning ), "prepareZoning" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::isInCombat ), "isInCombat" );
-   
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getCurrency ), "getCurrency" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::addCurrency ), "addCurrency" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::removeCurrency ), "removeCurrency" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getCrystal ), "getCrystals" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::addCrystal ), "addCrystals" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::removeCrystal ), "removeCrystals" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::updateQuest ), "questUpdate" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::finishQuest ), "questFinish" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::sendQuestMessage ), "questMessage" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestSeq ), "questGetSeq" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::hasQuest ), "hasQuest" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getZoneId ), "getZoneId" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::handleScriptSkill ), "handleScriptSkill" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getOpeningSequence ), "getOpeningSequence" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setOpeningSequence ), "setOpeningSequence" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Core::Event::mapEventActorToRealActor ), "mapActor" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8A ), "getQuestUI8A" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8B ), "getQuestUI8B" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8C ), "getQuestUI8C" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8D ), "getQuestUI8D" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8E ), "getQuestUI8E" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8F ), "getQuestUI8F" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8AH ), "getQuestUI8AH" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8BH ), "getQuestUI8BH" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8CH ), "getQuestUI8CH" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8DH ), "getQuestUI8DH" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8EH ), "getQuestUI8EH" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8FH ), "getQuestUI8FH" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8AL ), "getQuestUI8AL" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8BL ), "getQuestUI8BL" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8CL ), "getQuestUI8CL" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8DL ), "getQuestUI8DL" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8EL ), "getQuestUI8EL" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI8FL ), "getQuestUI8FL" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI16A ), "getQuestUI16A" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI16B ), "getQuestUI16B" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI16C ), "getQuestUI16C" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestUI32A ), "getQuestUI32A" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestBitFlag8 ), "getQuestBitFlag8" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestBitFlag16 ), "getQuestBitFlag16" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestBitFlag24 ), "getQuestBitFlag24" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestBitFlag32 ), "getQuestBitFlag32" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestBitFlag40 ), "getQuestBitFlag40" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::getQuestBitFlag48 ), "getQuestBitFlag48" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8A ), "setQuestUI8A" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8B ), "setQuestUI8B" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8C ), "setQuestUI8C" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8D ), "setQuestUI8D" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8E ), "setQuestUI8E" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8F ), "setQuestUI8F" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8AH ), "setQuestUI8AH" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8BH ), "setQuestUI8BH" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8CH ), "setQuestUI8CH" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8DH ), "setQuestUI8DH" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8EH ), "setQuestUI8EH" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8FH ), "setQuestUI8FH" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8AL ), "setQuestUI8AL" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8BL ), "setQuestUI8BL" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8CL ), "setQuestUI8CL" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8DL ), "setQuestUI8DL" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8EL ), "setQuestUI8EL" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI8FL ), "setQuestUI8FL" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI16A ), "setQuestUI16A" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI16B ), "setQuestUI16B" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI16C ), "setQuestUI16C" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestUI32A ), "setQuestUI32A" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestBitFlag8 ), "setQuestBitFlag8" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestBitFlag16 ), "setQuestBitFlag16" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestBitFlag24 ), "setQuestBitFlag24" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestBitFlag32 ), "setQuestBitFlag32" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestBitFlag40 ), "setQuestBitFlag40" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::setQuestBitFlag48 ), "setQuestBitFlag48" );
-
-   m_pChaiHandler->add(chaiscript::fun(&Entity::Player::giveQuestRewards), "giveQuestRewards");
-
-   m_pChaiHandler->add( chaiscript::fun< void, Entity::Player, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t >( &Entity::Player::eventPlay ), "eventPlay" );
-   m_pChaiHandler->add( chaiscript::fun< void, Entity::Player, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, EventReturnCallback >( &Entity::Player::eventPlay ), "eventPlay" );
-   m_pChaiHandler->add( chaiscript::fun< void, Entity::Player, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, EventReturnCallback >( &Entity::Player::eventPlay ), "eventPlay" );
-   m_pChaiHandler->add( chaiscript::fun< void, Entity::Player, uint32_t, uint32_t, uint32_t, EventReturnCallback >( &Entity::Player::eventPlay ), "eventPlay" );
-   m_pChaiHandler->add( chaiscript::fun< void, Entity::Player, uint32_t, uint32_t, uint32_t >( &Entity::Player::eventPlay ), "eventPlay" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::eventActionStart ), "eventActionStart" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::eventItemActionStart ), "eventItemActionStart" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::changePosition ), "changePos" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::tryAddItem ), "tryAddItem" );
-
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::isAetheryteRegistered ), "isAetheryteRegistered" );
-   m_pChaiHandler->add( chaiscript::fun( &Entity::Player::isActionLearned ), "isActionLearned" );
-
-   m_pChaiHandler->add( chaiscript::base_class< Entity::Actor, Entity::Player >() );
-   m_pChaiHandler->add( chaiscript::base_class< Entity::Actor, Entity::BattleNpc >() );
-   m_pChaiHandler->add( chaiscript::user_type< Entity::Actor >(), "Actor" );
-   m_pChaiHandler->add( chaiscript::user_type< Entity::Player >(), "Player" );
-   m_pChaiHandler->add( chaiscript::user_type< Entity::BattleNpc >(), "BattleNpc" );
-   m_pChaiHandler->add( chaiscript::user_type< StatusEffect::StatusEffect >(), "StatusEffect" );
-
-   m_pChaiHandler->add( chaiscript::fun( &StatusEffect::StatusEffect::registerTickEffect ), "registerTickEffect" );
-
-   m_pChaiHandler->add( chaiscript::user_type< Zone >(), "Zone" );
-   m_pChaiHandler->add( chaiscript::fun( &Zone::getName ), "getName" );
-
-   m_pChaiHandler->add( chaiscript::fun( &registerBnpcTemplate ), "registerBnpcTemplate" );
-
-   // EVENT BINDINGS
-   /////////////////////////////////////////////////////////////////////////////////////////////
-
-   std::set< std::string > chaiFiles;
-
-   loadDir( g_serverZone.getConfig()->getValue< std::string >( "Settings.General.ScriptPath", "../scripts/chai" ), chaiFiles );
-
-   uint16_t scriptCount = 0;
-   uint16_t errorCount = 0;
-   for( auto itr = chaiFiles.begin(); itr != chaiFiles.end(); ++itr )
-   {
-      auto& fileName = *itr;
-
-      try
-      {
-         m_pChaiHandler->eval_file( fileName );
-         scriptCount++;
-      }
-      catch( std::exception& e )
-      {
-         g_log.Log( LoggingSeverity::error, e.what() );
-         errorCount++;
-      }
-
-   }
-
-   g_log.info( "\tloaded " + std::to_string( scriptCount ) +
-               " scripts, " + std::to_string( errorCount ) + " errors." );
-
-   std::function<std::string( Entity::Player& ) > f =
-      m_pChaiHandler->eval< std::function<std::string( Entity::Player& ) > >( "onFirstEnterWorld" );
-
-   m_onFirstEnterWorld = f;
-
-
-   return true;
-}
-
diff --git a/src/servers/Server_Zone/ServerZone.cpp b/src/servers/Server_Zone/ServerZone.cpp
index a863b06a..8044f7ec 100644
--- a/src/servers/Server_Zone/ServerZone.cpp
+++ b/src/servers/Server_Zone/ServerZone.cpp
@@ -64,7 +64,7 @@ size_t Core::ServerZone::getSessionCount() const
    return m_sessionMapById.size();
 }
 
-bool Core::ServerZone::registerBnpcTemplate( std::string templateName, uint32_t bnpcBaseId, 
+bool Core::ServerZone::registerBnpcTemplate( std::string templateName, uint32_t bnpcBaseId,
                                              uint32_t bnpcNameId, uint32_t modelId, std::string aiName )
 {
 
@@ -222,14 +222,14 @@ void Core::ServerZone::run( int32_t argc, char* argv[] )
    Network::HivePtr hive( new Network::Hive() );
    Network::addServerToHive< Network::GameConnection >( m_ip, m_port, hive );
 
+   g_scriptMgr.init();
+
    g_log.info( "ZoneMgr: Setting up zones" );
    g_zoneMgr.createZones();
 
-   g_scriptMgr.init();
-
    std::vector< std::thread > thread_list;
    thread_list.emplace_back( std::thread( std::bind( &Network::Hive::Run, hive.get() ) ) );
-   
+
    g_log.info( "Server listening on port: " + std::to_string( m_port ) );
    g_log.info( "Ready for connections..." );