diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..d0faed9
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Rodolfo Herrera Hernandez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/Zenda b/Zenda
index 8cce099..a802885 100755
Binary files a/Zenda and b/Zenda differ
diff --git a/Zenda.cxx b/Zenda.cxx
index 0dc132d..7177432 100644
--- a/Zenda.cxx
+++ b/Zenda.cxx
@@ -1,13 +1,11 @@
 #include <iostream>
 using namespace std;
 
-#include "src/Engine.hxx" // Import Engine
+#include "src/Engine.hxx"
 
-int main(int argc, char* argv[]){
+int main(int argc, char *argv[]){
 
-    ZendaJS ZendaJS; // Creating instance
-
-    ZendaJS.Initialize(argc, argv); // Initialize Zenda
+    Initialize(argc, argv);
 
     return 0;
 }
\ No newline at end of file
diff --git a/examples/computer.js b/examples/computer.js
index cca3c87..f4d26c4 100644
--- a/examples/computer.js
+++ b/examples/computer.js
@@ -5,9 +5,9 @@ console.log(OperativeSystem);
 
 // Using sleep for wait and execute instructions after wait
 console.log('Showing network interface in next 5 seconds...');
-sleep(5);
+sleep(5000);
 
-// Executin command by OS
+// Executing command by OS
 if(OperativeSystem.startsWith('WIN')){
 
     // Running command
diff --git a/examples/fake_data_generator.js b/examples/fake_data_generator.js
index 1f661a3..806a53b 100644
--- a/examples/fake_data_generator.js
+++ b/examples/fake_data_generator.js
@@ -41,7 +41,7 @@ class FakerGenerator{
     }
 
     // Using PythonString
-    DataOutput = () => pythonString(`
+    DataOutput = () => pythonQuickString(`
 from faker import Faker
 from faker.providers import internet
 
diff --git a/examples/import/library.js b/examples/import/library.js
index 7ee606b..ff6e63f 100644
--- a/examples/import/library.js
+++ b/examples/import/library.js
@@ -1,5 +1,5 @@
 export const SayHelloWithPython = () => {
-    pythonString("print('Hello world')");
+    pythonQuickString("print('Hello world')");
 }
 
 export const MyVar = "Hello";
diff --git a/examples/misc.js b/examples/misc.js
index 72ccfd5..b207a44 100644
--- a/examples/misc.js
+++ b/examples/misc.js
@@ -5,7 +5,4 @@ sleep(1000); // 1 second  / 500 = 500 ms
 creator();
 
 // Version -> Get Zenda version
-version();
-
-// Getcwd -> Get current working directory
-console.log(getcwd())
\ No newline at end of file
+version();
\ No newline at end of file
diff --git a/examples/python_integration.js b/examples/python_integration.js
index a73d20d..3e6bb0f 100644
--- a/examples/python_integration.js
+++ b/examples/python_integration.js
@@ -14,9 +14,12 @@ Your message is {MESSAGE} and it contains {len(MESSAGE)} characteres!
 `;
 
 // Calling the pythonString function for execute code
-pythonString(code);
+pythonQuickString(code);
 
 // Calling Python File
-pythonFile('examples/PyIntegrationExample.py')
+pythonQuickFile('examples/PyIntegrationExample.py')
 
-// You need enter exact python file location :)
\ No newline at end of file
+// You need enter exact python file location :)
+
+// Use pythonFancyFile for get better perfomance, u need python in your OS.
+pythonFancyFile('examples/PyIntegrationExample.py')
\ No newline at end of file
diff --git a/src/Engine.hxx b/src/Engine.hxx
index 3ebde4f..1544198 100644
--- a/src/Engine.hxx
+++ b/src/Engine.hxx
@@ -1,14 +1,7 @@
 #include <iostream>
-#include "Utility.hxx"
-using namespace std;
 
 #include <v8.h>
 #include <libplatform/libplatform.h>
-using namespace v8;
-
-#include <cassert>
-#include <cstdlib>
-#include <functional>
 
 #ifdef __WIN32
 	#include <Windows.h>
@@ -19,104 +12,22 @@ using namespace v8;
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
 
-#include <vector>
-
-namespace Modules{
-
-    MaybeLocal<Module> CallResolve(Local<Context> MContext, Local<String> Specifier, Local<Module> Referrer);
-
-    MaybeLocal<Module> Load(char Code[], char Name[], Local<Context> MContext){
-        Local<String> VMCode = String::NewFromUtf8(MContext->GetIsolate(), Code).ToLocalChecked();
-
-        ScriptOrigin Origin(
-            String::NewFromUtf8(MContext->GetIsolate(), Name).ToLocalChecked(),
-
-            Integer::New(MContext->GetIsolate(), 0),
-
-            Integer::New(MContext->GetIsolate(), 0),
-
-            False(MContext->GetIsolate()),
-
-            Local<Integer>(),
-
-            Local<Value>(),
-
-            False(MContext->GetIsolate()),
-
-            False(MContext->GetIsolate()),
-
-            True(MContext->GetIsolate())
-        );
-
-        Context::Scope ContextScope(MContext);
-
-        ScriptCompiler::Source LSource(VMCode, Origin);
-
-        MaybeLocal<Module> LModule;
-
-        LModule = ScriptCompiler::CompileModule(MContext->GetIsolate(), &LSource);
-
-        return LModule;
-    }
-
-    Local<Module> Check(MaybeLocal<Module> MaybeModule, Local<Context> MContext){
-        Local<Module> LModule;
-
-        if(!MaybeModule.ToLocal(&LModule)){
-            cout << "Error loading module" << endl;
-
-            exit(EXIT_FAILURE);
-        }
-
-        Maybe<bool> Result = LModule->InstantiateModule(MContext, CallResolve);
-
-        if(Result.IsNothing()){
-            cout << "Can't instantiate module." << endl;
-            
-            exit(EXIT_FAILURE);
-        }
-
-        return LModule;
-    }
-
-    Local<Value> Execute(Local<Module> LModule, Local<Context> MContext, bool NsObject = false){
-        Local<Value> ReturnValue;
-
-        if(!LModule->Evaluate(MContext).ToLocal(&ReturnValue)){
-            cout << "Error evaluating module." << endl;
-
-            exit(EXIT_FAILURE);
-        }
-
-        if(NsObject)
-            return LModule->GetModuleNamespace();
-        else
-            return ReturnValue;
-    }
-
-    MaybeLocal<Module> CallResolve(Local<Context> MContext, Local<String> Specifier, Local<Module> Referrer){
-        String::Utf8Value Str(MContext->GetIsolate(), Specifier);
-
-        return Load(ReadFile(*Str), *Str, MContext);
-    }
-
-    MaybeLocal<Promise> CallDynamic(Local<Context> MContext, Local<ScriptOrModule> Referrer, Local<String> Specifier){
-        Local<Promise::Resolver> Resolver = Promise::Resolver::New(MContext).ToLocalChecked();
-
-        MaybeLocal<Promise> LPromise(Resolver->GetPromise());
-
-        String::Utf8Value Name(MContext->GetIsolate(), Specifier);
+#include <cassert>
 
-        Local<Module> LModule = Check(Load(ReadFile(*Name), *Name, MContext), MContext);
+using namespace std;
+using namespace v8;
 
-        Local<Value> ReturnValue = Execute(LModule, MContext, true);
+#include "utils/String.hxx"
+#include "utils/Shared.hxx"
 
-        Maybe<bool> MResolve = Resolver->Resolve(MContext, ReturnValue);
+#include "Module.hxx"
+#include "Global.hxx"
 
-        return LPromise;
-    }
+#include "methods/Misc.hxx"
+#include "methods/Python.hxx"
 
-}
+#include "objects/Console.hxx"
+#include "objects/System.hxx"
 
 class ObjectCreator{
     private:
@@ -127,9 +38,7 @@ class ObjectCreator{
     public:
         ObjectCreator(Isolate * isolate, const char* objectname){
             this->isolate = isolate;
-          
             this->ObjectInstance = ObjectTemplate::New(this->isolate);
-          
             this->name = String::NewFromUtf8(
                 this->isolate, objectname, NewStringType::kNormal
             ).ToLocalChecked();
@@ -138,10 +47,8 @@ class ObjectCreator{
         ObjectCreator SetPropertyMethod(const char* propertymethod, void (*callback)(const FunctionCallbackInfo<Value>& Arguments)){
             this->ObjectInstance->Set(
                 String::NewFromUtf8(this->isolate, propertymethod, NewStringType::kNormal).ToLocalChecked(),
-                
                 FunctionTemplate::New(this->isolate, callback)
             );
-            
             return *this;
         }
 
@@ -149,7 +56,6 @@ class ObjectCreator{
             Local<Object> Instance = this->ObjectInstance->NewInstance(
                 this->isolate->GetCurrentContext()
             ).ToLocalChecked();
-            
             this->isolate->GetCurrentContext()->Global()->Set(
                 this->isolate->GetCurrentContext(),
                 this->name,
@@ -158,546 +64,230 @@ class ObjectCreator{
         }
 };
 
-class ZendaJS{
-    private:
-        unique_ptr<Platform> platform;
-
-        Isolate::CreateParams create_params;
-
-        Isolate* isolate;
-
-        Local<ObjectTemplate> global;
-
-        vector<string> ZendaJSCoreFiles;
-
-        static void Version(const FunctionCallbackInfo<Value>& Arguments){
-            HandleScope Scope(Arguments.GetIsolate());
-
-            PrintVersion();
-        }
-
-        static void Creator(const FunctionCallbackInfo<Value>& Arguments){
-            HandleScope Scope(Arguments.GetIsolate());
-
-            PrintCreator();
-        }
-
-        static void PythonString(const FunctionCallbackInfo<Value>& Arguments){
-            Py_Initialize();
-            
-            for(unsigned short int i = 0; i < Arguments.Length(); i++){
-                HandleScope Scope(Arguments.GetIsolate());
-
-                String::Utf8Value Code(Arguments.GetIsolate(), Arguments[i]);
-
-                char const* CharCode = ToCString(Code);
-
-                PyRun_SimpleString(CharCode);
-            }
-
-            Py_Finalize();
-        }
-
-        static void PythonFile(const FunctionCallbackInfo<Value>& Arguments){
-            Py_Initialize();
-
-            for(unsigned short int i = 0; i < Arguments.Length(); i++){
-                HandleScope Scope(Arguments.GetIsolate());
-
-                String::Utf8Value File(Arguments.GetIsolate(), Arguments[i]);
-
-                char const* CharFile = ToCString(File);
-
-                FILE* PyFile;
+ObjectCreator CreateObject(const char* ObjectName){
+    ObjectCreator ObjectCreatorInstance(ZendaIsolate, ObjectName);
+    return ObjectCreatorInstance;
+}
 
-                PyFile = fopen(CharFile, "r");
+// By declaring the function and 
+// then defining them and not having order 
+// errors due to the use of a functional programming paradigm.
+void CreatheMethod(const char* MethodName, void(*Callback)(const FunctionCallbackInfo<Value>& Arguments));
+void AddCoreJavascriptFile(string Path);
+void CreatePlatform(char* argv[]);
+void Initialize(int argc, char* argv[]);
+bool ExecuteString(Local<String> Source, const char* Filename);
+void Shell(Local<Context> SContext, Platform* SPlatform);
+void ReportException(TryCatch* try_catch);
+void CreateVirtualMachine();
+void CreateGlobalEnvironment();
+void ShutdownVirtualMachine();
+void LoadCoreJavascriptFiles();
+void EngineEnvironMethods();
+void EngineEnvironObjects();
+void EngineEnvironCoreJavascriptFiles();
+Local<Context> CreateLocalContext();
+
+void CreateMethod(const char* MethodName, void(*Callback)(const FunctionCallbackInfo<Value>& Arguments)){
+    ZendaGlobal->Set(
+        String::NewFromUtf8(ZendaIsolate, MethodName, NewStringType::kNormal).ToLocalChecked(),
+        FunctionTemplate::New(ZendaIsolate, Callback)
+    );
+}
 
-                if(PyFile == NULL)
-                    cout << "ZendaJS -> An error ocurred while trying open <" << CharFile << "> in pythonFile() function." << endl;
-                else
-                    PyRun_SimpleFile(PyFile, CharFile);
+Local<Context> CreateLocalContext(){
+    return Context::New(ZendaIsolate, NULL, ZendaGlobal);
+}
 
-                fclose(PyFile);
-            }
+void AddCoreJavascriptFile(string Path){
+    ZendaJavascriptCoreFiles.push_back(Path);
+}
 
-            Py_Finalize();
-        }
+void CreatePlatform(char* argv[]){
+    V8::InitializeICUDefaultLocation(argv[0]);
+    V8::InitializeExternalStartupData(argv[0]);
+    ZendaPlatform = platform::NewDefaultPlatform();
+    V8::InitializePlatform(ZendaPlatform.get());
+    V8::Initialize();
+}
 
-        static void GetCurrentWorkingDirectory(const FunctionCallbackInfo<Value>& Arguments){
-            HandleScope Scope(Arguments.GetIsolate());
+void CreateVirtualMachine(){
+    ZendaCreateParams.array_buffer_allocator = ArrayBuffer::Allocator::NewDefaultAllocator();
+    ZendaIsolate = Isolate::New(ZendaCreateParams);
+    ZendaIsolate->SetHostImportModuleDynamicallyCallback(CallDynamic);
+}
 
-            string Directory = CurrentWorkingDirectory();
+void ShutdownVirtualMachine(){
+    ZendaIsolate->Dispose();
+    V8::Dispose();
+    V8::ShutdownPlatform();
+    delete ZendaCreateParams.array_buffer_allocator;
+}
 
-            Arguments.GetReturnValue().Set(
-                String::NewFromUtf8(
-                    Arguments.GetIsolate(),
-                    Directory.c_str(),
-                    NewStringType::kNormal,
-                    static_cast<int>(Directory.length())
-                ).ToLocalChecked()
-            );
+bool ExecuteString(Local<String> Source, const char* Filename){
+    TryCatch try_catch(ZendaIsolate);
+    ScriptOrigin origin(
+        String::NewFromUtf8(ZendaIsolate, Filename, NewStringType::kNormal).ToLocalChecked()
+    );
+    Local<Script> LSCript;
+
+    if(!Script::Compile(ZendaIsolate->GetCurrentContext(), Source, &origin).ToLocal(&LSCript)){
+        ReportException(&try_catch);
+        return false;
+    }else{
+        Local<Value> Output;
+        if(!LSCript->Run(ZendaIsolate->GetCurrentContext()).ToLocal(&Output)){
+            assert(try_catch.HasCaught());
+            ReportException(&try_catch);
+            return false;
+        }else{
+            assert(!try_catch.HasCaught());
+            return true;
         }
+    }
+}
 
-        static void Sleep(const FunctionCallbackInfo<Value>& Arguments){
-            HandleScope Scope(Arguments.GetIsolate());
-            
-            String::Utf8Value SleepTime(Arguments.GetIsolate(), Arguments[0]);
+bool ExecuteFile(const char* Filename){
+    Local<String> Source;
+    if(!ReadFileUsingV8(Filename, ZendaIsolate).ToLocal(&Source))
+        return false;
+    if(!ExecuteString(Source, Filename))
+        return false;
+    return true;
+}
 
-            char const* CharSleepTime = ToCString(SleepTime);
+void LoadCoreJavascriptFiles(){
+    EngineEnvironCoreJavascriptFiles();
 
-            sleep(stoi(CharSleepTime) / 1000);
-        }
+    for(unsigned short int i = 0; i < ZendaJavascriptCoreFiles.size(); i++)
+        ExecuteFile(ZendaJavascriptCoreFiles.at(i).c_str());
+}
 
-        static void ConsoleLog(const FunctionCallbackInfo<Value>& Arguments){
-            for(unsigned short int i = 0; i < Arguments.Length(); i++){
-                HandleScope Scope(Arguments.GetIsolate());
-   
-                if(i > 0) cout << " ";
+void CreateGlobalEnvironment(){
+    ZendaGlobal = ObjectTemplate::New(ZendaIsolate);
+}
 
-                String::Utf8Value Text(Arguments.GetIsolate(), Arguments[i]);
+void EngineEnvironMethods(){
+    CreateMethod("version", Version);
+    CreateMethod("creator", Creator);
+    CreateMethod("sleep", Sleep);
+    CreateMethod("pythonQuickString", PythonQuickString);
+    CreateMethod("pythonQuickFile", PythonQuickFile);
+    CreateMethod("pythonFancyFile", PythonFancyFile);
+}
 
-                const char* CharText = ToCString(Text);
+void EngineEnvironObjects(){
+    CreateObject("console")
+        .SetPropertyMethod("log", ConsoleLog)
+        .SetPropertyMethod("input", ConsoleInput)
+        .SetPropertyMethod("clear", ConsoleClear)
+        .SetPropertyMethod("setColor", ConsoleSetColor)
+        .SetPropertyMethod("setStyle", ConsoleSetStyle)
+        .SetPropertyMethod("setBackground", ConsoleSetBackground)
+        .SetPropertyMethod("getColor", ConsoleGetColor)
+        .SetPropertyMethod("getStyle", ConsoleGetStyle)
+        .SetPropertyMethod("getBackground", ConsoleGetBackground)
+        .Register();
+
+    CreateObject("system")
+        .SetPropertyMethod("platform", SystemPlatform)
+        .SetPropertyMethod("execute", SystemExecute)
+        .Register();
+}
 
-                cout << CharText;
-            }
+void EngineEnvironCoreJavascriptFiles(){
+}
 
+void Shell(Local<Context> SContext, Platform* SPlatform){
+    cout << "ZendaJS<Beta> [" << ZendaVersion << "] - By " << ZendaCreator << "." << endl << "Happy hacking!" << endl << endl;
+    static const int kBufferSize = 256;
+    Context::Scope context_scope(SContext);
+    Local<String> name(
+        String::NewFromUtf8(SContext->GetIsolate(), "(shell)", NewStringType::kNormal).ToLocalChecked()
+    );
+
+    while(true){
+        char Buffer[kBufferSize];
+        fprintf(stderr, "Console -> ");
+        char* Code = fgets(Buffer, kBufferSize, stdin);
+        if(Code == NULL) break;
+        HandleScope handle_scope(SContext->GetIsolate());
+        ExecuteString(
+            String::NewFromUtf8(SContext->GetIsolate(), Code).ToLocalChecked(),
+            ""
+        );
+        while(platform::PumpMessageLoop(SPlatform, SContext->GetIsolate()))
+            continue;
             cout << endl;
         }
+}
 
-        static void ConsoleSetColor(const FunctionCallbackInfo<Value>& Arguments){
-            HandleScope Scope(Arguments.GetIsolate());
-
-            String::Utf8Value ColorIdentifier(Arguments.GetIsolate(), Arguments[0]);
-            
-            const char* CharColorIdentifier = ToCString(ColorIdentifier);
-            
-            cout << ConsoleColor(CharColorIdentifier);
-        }
-
-        static void ConsoleSetStyle(const FunctionCallbackInfo<Value>& Arguments){
-            HandleScope Scope(Arguments.GetIsolate());
-
-            String::Utf8Value StyleIdentifier(Arguments.GetIsolate(), Arguments[0]);
-
-            const char* CharStyleIdentifier = ToCString(StyleIdentifier);
-
-            cout << ConsoleStyle(CharStyleIdentifier);
-        }
-
-        static void ConsoleSetBackground(const FunctionCallbackInfo<Value>& Arguments){
-            HandleScope Scope(Arguments.GetIsolate());
-
-            String::Utf8Value BackgroundIdentifier(Arguments.GetIsolate(), Arguments[0]);
-            
-            const char* CharBackgroundIdentifier = ToCString(BackgroundIdentifier);
-            
-            cout << ConsoleBackground(CharBackgroundIdentifier);
-        }
-
-        static void ConsoleGetBackground(const FunctionCallbackInfo<Value>& Arguments){
-            HandleScope Scope(Arguments.GetIsolate());
-
-            String::Utf8Value BackgroundIdentifier(Arguments.GetIsolate(), Arguments[0]);
-
-            const char* CharBackgroundIdentifier = ToCString(BackgroundIdentifier);
-
-            string Background = ConsoleBackground(CharBackgroundIdentifier);
-
-            Arguments.GetReturnValue().Set(
-                String::NewFromUtf8(
-                    Arguments.GetIsolate(),
-                    Background.c_str(),
-                    NewStringType::kNormal,
-                    static_cast<int>(Background.length())
-                ).ToLocalChecked()
-            );
-        }
-
-        static void ConsoleGetStyle(const FunctionCallbackInfo<Value>& Arguments){
-            HandleScope Scope(Arguments.GetIsolate());
-
-            String::Utf8Value StyleIdentifier(Arguments.GetIsolate(), Arguments[0]);
-            
-            const char* CharStyleIdentifier = ToCString(StyleIdentifier);
-            
-            string Style = ConsoleStyle(CharStyleIdentifier);
-            
-            Arguments.GetReturnValue().Set(
-                String::NewFromUtf8(
-                    Arguments.GetIsolate(),
-                    Style.c_str(),
-                    NewStringType::kNormal,
-                    static_cast<int>(Style.length())
-                ).ToLocalChecked()
-            );
-        }
-
-        static void ConsoleGetColor(const FunctionCallbackInfo<Value>& Arguments){
-            HandleScope Scope(Arguments.GetIsolate());
-
-            String::Utf8Value ColorIdentifier(Arguments.GetIsolate(), Arguments[0]);
-
-            const char* CharColorIdentifier = ToCString(ColorIdentifier);
-
-            string Color = ConsoleColor(CharColorIdentifier);
-
-            Arguments.GetReturnValue().Set(
-                String::NewFromUtf8(
-                    Arguments.GetIsolate(),
-                    Color.c_str(),
-                    NewStringType::kNormal,
-                    static_cast<int>(Color.length())
-                ).ToLocalChecked()
-            );
-        }
-
-        static void ConsoleClear(const FunctionCallbackInfo<Value>& Arguments){
-            HandleScope Scope(Arguments.GetIsolate());
-        
-            ClearConsole();
-        }
-        
-        static void ConsoleInput(const FunctionCallbackInfo<Value>& Arguments){
-            for(unsigned short int i = 0; i < Arguments.Length(); i++){
-                HandleScope scope(Arguments.GetIsolate());
-
-                if(i > 0) cout << " ";
-
-                String::Utf8Value Text(Arguments.GetIsolate(), Arguments[i]);
-
-                const char* CharText = ToCString(Text);
-
-                cout << CharText;
-            }
-
-            string Response;
-
-            getline(cin, Response);
-
-            Arguments.GetReturnValue().Set(
-                String::NewFromUtf8(
-                    Arguments.GetIsolate(),
-                    Response.c_str(),
-                    NewStringType::kNormal,
-                    static_cast<int>(Response.length())
-                ).ToLocalChecked()
-            );
-        }
-
-        static void SystemExecute(const FunctionCallbackInfo<Value>& Arguments){
-            for(unsigned short int i = 0; i < Arguments.Length(); i++){
-                HandleScope Scope(Arguments.GetIsolate());
-
-                String::Utf8Value Command(Arguments.GetIsolate(), Arguments[i]);
-
-                const char* CharCommand = ToCString(Command);
-
-                system(CharCommand);
-            }
-        }
-
-        static void SystemPlatform(const FunctionCallbackInfo<Value>& Arguments){
-            HandleScope Scope(Arguments.GetIsolate());
-
-            string OS = OperativeSystem();
-
-            Arguments.GetReturnValue().Set(
-                String::NewFromUtf8(
-                    Arguments.GetIsolate(),
-                    OS.c_str(),
-                    NewStringType::kNormal,
-                    static_cast<int>(OS.length())
-                ).ToLocalChecked()
-            );
-        }
-
-    protected:
-        Local<Context> CreateLocalContext(){
-            return Context::New(this->isolate, NULL, this->global);
-        }
-    
-        Local<ObjectTemplate> GetGlobal(){
-            return this->global;
-        }
-
-    public:
-        Isolate* GetIsolate(){
-            return this->isolate;
-        }
-
-        void CreatePlatform(char* argv[]){
-                    V8::InitializeICUDefaultLocation(argv[0]);
-        
-                    V8::InitializeExternalStartupData(argv[0]);
-        
-                    this->platform = platform::NewDefaultPlatform();
-        
-                    V8::InitializePlatform(platform.get());
-        
-                    V8::Initialize();
-        }
-
-        void CreateVM(){
-            this->create_params.array_buffer_allocator = ArrayBuffer::Allocator::NewDefaultAllocator();
-        
-            this->isolate = Isolate::New(this->create_params);
-
-            this->isolate->SetHostImportModuleDynamicallyCallback(Modules::CallDynamic);
-        }
-
-        void ShutdownVM(){
-            this->isolate->Dispose();
-            
-            V8::Dispose();
-            
-            V8::ShutdownPlatform();
-            
-            delete this->create_params.array_buffer_allocator;
-        }
-        
-        void LoadZendaJSFiles(){
-            this->ZendaJSFiles();
-
-            for(unsigned short int i = 0; i < this->ZendaJSCoreFiles.size(); i++)
-                this->ExecuteFile(this->ZendaJSCoreFiles.at(i).c_str());
-        }
-        
-        void Shell(Local<Context> SContext, Platform* SPlatform){
-            ClearConsole();
-            
-            PrintCreator();
-
-            cout << "Running in v" << ZendaVersion << ", Remember drink water and Happy Hacking!" << endl << endl;
-
-            static const int kBufferSize = 256;
-
-            Context::Scope context_scope(SContext);
-
-            Local<String> name(
-                String::NewFromUtf8(SContext->GetIsolate(), "(shell)", NewStringType::kNormal).ToLocalChecked()
-            );
-
-            while(true){
-                char Buffer[kBufferSize];
-
-                fprintf(stderr, "Console -> ");
-
-                char* Code = fgets(Buffer, kBufferSize, stdin);
-
-                if(Code == NULL) break;
-
-                HandleScope handle_scope(SContext->GetIsolate());
-
-                this->ExecuteString(
-                    String::NewFromUtf8(SContext->GetIsolate(), Code).ToLocalChecked(),
-                    ""
-                );
-
-                while(platform::PumpMessageLoop(SPlatform, SContext->GetIsolate()))
-                    continue;
-                
-                cout << endl;
-            }
-        }
-
-        void CreateGlobalEnvironment(){
-            this->global = ObjectTemplate::New(this->isolate);
-        }
-
-        void ZendaMethods(){
-            this->CreateMethod("version", Version);
-
-            this->CreateMethod("creator", Creator);
-
-            this->CreateMethod("getcwd", GetCurrentWorkingDirectory);
-
-            this->CreateMethod("sleep", Sleep);
-
-            this->CreateMethod("pythonString", PythonString);
-
-            this->CreateMethod("pythonFile", PythonFile);
-        }
-
-        void ZendaObjects(){
-            this->CreateObject("console")
-                .SetPropertyMethod("log", ConsoleLog)
-                .SetPropertyMethod("input", ConsoleInput)
-                .SetPropertyMethod("clear", ConsoleClear)
-                
-                .SetPropertyMethod("setColor", ConsoleSetColor)
-                .SetPropertyMethod("setStyle", ConsoleSetStyle)
-                .SetPropertyMethod("setBackground", ConsoleSetBackground)
-                
-                .SetPropertyMethod("getColor", ConsoleGetColor)
-                .SetPropertyMethod("getStyle", ConsoleGetStyle)
-                .SetPropertyMethod("getBackground", ConsoleGetBackground)
-                .Register();
-
-            this->CreateObject("system")
-                .SetPropertyMethod("platform", SystemPlatform)
-                .SetPropertyMethod("execute", SystemExecute)
-                .Register();
-        }
-
-        void ZendaJSFiles(){
-        }
-
-        void ReportException(TryCatch* try_catch){
-            String::Utf8Value exception(this->GetIsolate(), try_catch->Exception());
-
-            const char* ExceptionString = ToCString(exception);
-
-            Local<Message> message = try_catch->Message();
-
-            if(message.IsEmpty())
-                cout << ExceptionString << endl;
-            else {
-                String::Utf8Value Filename(
-                    this->GetIsolate(), message->GetScriptOrigin().ResourceName()
-                );
-
-                const char* FilenameString = ToCString(Filename);
-
-                int LineNumber = message->GetLineNumber(
-                    this->GetIsolate()->GetCurrentContext()
-                ).FromJust();
-                
-                cout << "ZendaJS [Error in line " << to_string(LineNumber) << "] - [" << FilenameString << "]" << endl;
-                cout << endl << "-> " << ExceptionString << endl << endl;
-
-                String::Utf8Value SourceLine(
-                    this->GetIsolate(),
-                        message->GetSourceLine(this->GetIsolate()->GetCurrentContext()).ToLocalChecked()
-                );
-
-                const char* SourceLineString = ToCString(SourceLine);
-
-                cout << SourceLineString << endl;
-
-                unsigned int 
-                    Start = message->GetStartColumn(
-                        this->GetIsolate()->GetCurrentContext()
-                    ).FromJust(),
-
-                    End = message->GetEndColumn(
-                        this->GetIsolate()->GetCurrentContext()
-                    ).FromJust();
-
-                    for(unsigned int i = 0; i < Start; i++) 
-                        fprintf(stderr, " ");
-
-                    for(unsigned int i = Start; i < End; i++)
-                        fprintf(stderr, "^");
-
-                cout << endl;
-            }
-        }
-
-        bool ExecuteFile(const char* Filename){
-            Local<String> Source;
-
-            if(!ReadFileUsingV8(Filename, this->GetIsolate()).ToLocal(&Source))
-                return false;
-
-            if(!this->ExecuteString(Source, Filename))
-                return false;
-
-            return true;
-        }
-
-        bool ExecuteString(Local<String> Source, const char* Filename){
-            TryCatch try_catch(this->GetIsolate());
-
-            ScriptOrigin origin(
-                String::NewFromUtf8(this->GetIsolate(), Filename, NewStringType::kNormal).ToLocalChecked()
-            );
-
-            Local<Script> LScript;
-
-            if(!Script::Compile(this->GetIsolate()->GetCurrentContext(), Source, &origin).ToLocal(&LScript)){
-                this->ReportException(&try_catch);
-                
-                return false;
-            }else{
-                Local<Value> Output;
-
-                if(!LScript->Run(this->GetIsolate()->GetCurrentContext()).ToLocal(&Output)){
-                    assert(try_catch.HasCaught());
-                        
-                    this->ReportException(&try_catch);
-                        
-                    return false;
-                }else{
-                    assert(!try_catch.HasCaught());
-                        
-                    return true;
-                }
-            }
-        }
-
-        void CreateMethod(const char* MethodName, void(*Callback)(const FunctionCallbackInfo<Value>& Arguments)){
-            this->GetGlobal()->Set(
-                String::NewFromUtf8(this->GetIsolate(), MethodName, NewStringType::kNormal).ToLocalChecked(),
-                
-                FunctionTemplate::New(this->GetIsolate(), Callback)
+void ReportException(TryCatch* try_catch){
+    String::Utf8Value exception(ZendaIsolate, try_catch->Exception());
+    const char* ExceptionString = ToCString(exception);
+    Local<Message> message = try_catch->Message();
+    if(message.IsEmpty())
+        cout << ExceptionString << endl;
+    else{
+        String::Utf8Value Filename(
+            ZendaIsolate, message->GetScriptOrigin().ResourceName()
+        );
+        const char* FilenameString = ToCString(Filename);
+        int LineNumber = message->GetLineNumber(
+            ZendaIsolate->GetCurrentContext()
+        ).FromJust();
+        cout << "ZendaJS [Error in line " << to_string(LineNumber) << "] - [" << FilenameString << "]" << endl;
+        cout << endl << "-> " << ExceptionString << endl << endl;
+        String::Utf8Value SourceLine(
+            ZendaIsolate,
+                message->GetSourceLine(ZendaIsolate->GetCurrentContext()).ToLocalChecked()
             );
+        const char* SourceLineString = ToCString(SourceLine);
+        cout << SourceLineString << endl;
+        unsigned int 
+            Start = message->GetStartColumn(
+                ZendaIsolate->GetCurrentContext()
+            ).FromJust(),
+            End = message->GetEndColumn(
+                ZendaIsolate->GetCurrentContext()
+            ).FromJust();
+            for(unsigned int i = 0; i < Start; i++) 
+                fprintf(stderr, " ");
+            for(unsigned int i = Start; i < End; i++)
+                fprintf(stderr, "^");
+            cout << endl;
         }
+}
 
-
-        void AddZendaJSFile(string Path){
-            this->ZendaJSCoreFiles.push_back(Path);
-        }
-
-        void Initialize(int argc, char* argv[]){
-                this->CreatePlatform(argv);
-
-                this->CreateVM();
-
-            {
-                Isolate::Scope IsolateScope(this->GetIsolate());
-
-                HandleScope Scope(this->GetIsolate());
-
-                this->CreateGlobalEnvironment();
-
-                this->ZendaMethods();
-
-                for(unsigned short int i = 1; i < argc; ++i){
-                    const char* Argument = argv[i];
-
-                    Local<Context> LContext = this->CreateLocalContext();
-
-                    Context::Scope ContextScope(LContext);
-
-                    this->ZendaObjects();
-
-                    this->LoadZendaJSFiles();
-
-                    if(!strcmp(Argument, "--shell")){
-                        this->Shell(LContext, platform.get());
-                        break;
-                    }else if(!strcmp(Argument, "--version")){
-                        PrintVersion();
-                        break;
-                    }else if(!strcmp(Argument, "--creator")){
-                        PrintCreator();
-                        break;
-                    }else{
-                        char* Contents = ReadFile(argv[i]);
-
-                        Local<Module> LModule = Modules::Check(Modules::Load(Contents, argv[i], LContext), LContext);
-
-                        Local<Value> Returned = Modules::Execute(LModule, LContext);
-                    }
-                }
+void Initialize(int argc, char* argv[]){
+    CreatePlatform(argv);
+    CreateVirtualMachine();
+    {
+        Isolate::Scope IsolateScope(ZendaIsolate);
+        HandleScope Scope(ZendaIsolate);
+        CreateGlobalEnvironment();
+        EngineEnvironMethods();
+        for(unsigned short int i = 1; i < argc; ++i){
+            const char* Argument = argv[i];
+            Local<Context> LContext = CreateLocalContext();
+            Context::Scope ContextScope(LContext);
+            EngineEnvironObjects();
+            LoadCoreJavascriptFiles();
+            if(!strcmp(Argument, "--creator")){
+                cout << ZendaCreator << endl;
+                break;
+            }else if(!strcmp(Argument, "--version")){
+                cout << ZendaVersion << endl;
+                break;
+            }else if(!strcmp(Argument, "--shell")){
+                Shell(LContext, ZendaPlatform.get());
+                break;
             }
-
-            this->ShutdownVM();
+            char* Contents = ReadFile(strdup(Argument));
+            Local<Module> LModule = CheckModule(LoadModule(Contents, strdup(Argument), LContext), LContext);
+            Local<Value> Returned = ExecuteModule(LModule, LContext);
         }
-                
-        ObjectCreator CreateObject(const char* ObjectName){
-            ObjectCreator ObjectCreatorInstance(this->GetIsolate(), ObjectName);
+    }
 
-            return ObjectCreatorInstance;
-        }
-};
\ No newline at end of file
+    ShutdownVirtualMachine();
+}
\ No newline at end of file
diff --git a/src/Global.hxx b/src/Global.hxx
new file mode 100644
index 0000000..5eea3f1
--- /dev/null
+++ b/src/Global.hxx
@@ -0,0 +1,14 @@
+#include <iostream>
+#include <v8.h>
+using namespace std;
+using namespace v8;
+
+const char* ZendaVersion = "1.0.3";
+const char* ZendaCreator = "Rodolfo Herrera Hernandez";
+
+Isolate* ZendaIsolate;
+Local<String> ZendaName;
+Local<ObjectTemplate> ZendaGlobal;
+unique_ptr<Platform> ZendaPlatform;
+Isolate::CreateParams ZendaCreateParams;
+vector<string> ZendaJavascriptCoreFiles;
\ No newline at end of file
diff --git a/src/Module.hxx b/src/Module.hxx
new file mode 100644
index 0000000..f0e31d7
--- /dev/null
+++ b/src/Module.hxx
@@ -0,0 +1,67 @@
+#include <iostream>
+#include <v8.h>
+using namespace v8;
+using namespace std;
+
+MaybeLocal<Module> CallResolve(Local<Context> MContext, Local<String> Specifier, Local<Module> Referrer);
+
+MaybeLocal<Module> LoadModule(char Code[], char Name[], Local<Context> MContext){
+    Local<String> VMCode = String::NewFromUtf8(MContext->GetIsolate(), Code).ToLocalChecked();
+    ScriptOrigin Origin(
+        String::NewFromUtf8(MContext->GetIsolate(), Name).ToLocalChecked(),
+        Integer::New(MContext->GetIsolate(), 0),
+        Integer::New(MContext->GetIsolate(), 0),
+        False(MContext->GetIsolate()),
+        Local<Integer>(),
+        Local<Value>(),
+        False(MContext->GetIsolate()),
+        False(MContext->GetIsolate()),
+        True(MContext->GetIsolate())
+    );
+    Context::Scope ContextScope(MContext);
+    ScriptCompiler::Source LSource(VMCode, Origin);
+    MaybeLocal<Module> LModule;
+    LModule = ScriptCompiler::CompileModule(MContext->GetIsolate(), &LSource);
+    return LModule;
+}
+
+Local<Module> CheckModule(MaybeLocal<Module> MaybeModule, Local<Context> MContext){
+    Local<Module> LModule;
+    if(!MaybeModule.ToLocal(&LModule)){
+        cout << "An error has been ocurred trying read the file." << endl;
+        exit(EXIT_FAILURE);
+    }
+    Maybe<bool> Result = LModule->InstantiateModule(MContext, CallResolve);
+    if(Result.IsNothing()){
+        cout << "Can't instantiate module/s." << endl;
+        exit(EXIT_FAILURE);
+    }
+    return LModule;
+}
+
+Local<Value> ExecuteModule(Local<Module> LModule, Local<Context> MContext, bool NsObject = false){
+    Local<Value> ReturnValue;
+    if(!LModule->Evaluate(MContext).ToLocal(&ReturnValue)){
+        cout << "Error evaluating module." << endl;
+        exit(EXIT_FAILURE);
+    }
+    if(NsObject)
+        return LModule->GetModuleNamespace();
+    else
+        return ReturnValue;
+}
+
+MaybeLocal<Module> CallResolve(Local<Context> MContext, Local<String> Specifier, Local<Module> Referrer){
+    String::Utf8Value Str(MContext->GetIsolate(), Specifier);
+    return LoadModule(ReadFile(*Str), *Str, MContext);
+}
+
+MaybeLocal<Promise> CallDynamic(Local<Context> MContext, Local<ScriptOrModule> Referrer, Local<String> Specifier){
+    Local<Promise::Resolver> Resolver = Promise::Resolver::New(MContext).ToLocalChecked();
+    MaybeLocal<Promise> LPromise(Resolver->GetPromise());
+    String::Utf8Value Name(MContext->GetIsolate(), Specifier);
+    Local<Module> LModule = CheckModule(LoadModule(ReadFile(*Name), *Name, MContext), MContext);
+    Local<Value> ReturnValue = ExecuteModule(LModule, MContext, true);
+    Maybe<bool> MResolve = Resolver->Resolve(MContext, ReturnValue);
+    return LPromise;
+}
\ No newline at end of file
diff --git a/src/methods/Misc.hxx b/src/methods/Misc.hxx
new file mode 100644
index 0000000..055b03e
--- /dev/null
+++ b/src/methods/Misc.hxx
@@ -0,0 +1,16 @@
+static void Version(const FunctionCallbackInfo<Value>& Arguments){
+    HandleScope Scope(Arguments.GetIsolate());
+    cout << ZendaVersion << endl;
+}
+
+static void Creator(const FunctionCallbackInfo<Value>& Arguments){
+    HandleScope Scope(Arguments.GetIsolate());
+    cout << ZendaCreator << endl;
+}
+
+static void Sleep(const FunctionCallbackInfo<Value>& Arguments){
+    HandleScope Scope(Arguments.GetIsolate());
+    String::Utf8Value SleepTime(Arguments.GetIsolate(), Arguments[0]);
+    char const* CharSleepTime = ToCString(SleepTime);
+    sleep(stoi(CharSleepTime) / 1000);
+}
\ No newline at end of file
diff --git a/src/methods/Python.hxx b/src/methods/Python.hxx
new file mode 100644
index 0000000..0fa7dbe
--- /dev/null
+++ b/src/methods/Python.hxx
@@ -0,0 +1,36 @@
+static void PythonQuickString(const FunctionCallbackInfo<Value>& Arguments){
+    for(unsigned short int i = 0; i < Arguments.Length(); i++){
+        HandleScope Scope(Arguments.GetIsolate());
+        String::Utf8Value Code(Arguments.GetIsolate(), Arguments[i]);
+        char const* CharCode = ToCString(Code);
+        Py_Initialize();
+            PyRun_SimpleString(CharCode);
+        Py_Finalize();
+    }
+}
+
+static void PythonQuickFile(const FunctionCallbackInfo<Value>& Arguments){
+    for(unsigned short int i = 0; i < Arguments.Length(); i++){
+        HandleScope Scope(Arguments.GetIsolate());
+        String::Utf8Value File(Arguments.GetIsolate(), Arguments[i]);
+        char const* CharFile = ToCString(File);
+        Py_Initialize();
+            FILE* PyFile;
+            PyFile = fopen(CharFile, "r");
+            if(PyFile == NULL)
+                cout << "ZendaJS -> An error ocurred while trying open <" << CharFile << "> in pythonFile() function." << endl;
+            else
+                PyRun_SimpleFile(PyFile, CharFile);
+            fclose(PyFile);
+        Py_Finalize();
+    }
+}
+
+static void PythonFancyFile(const FunctionCallbackInfo<Value>& Arguments){
+    for(unsigned short int i = 0; i < Arguments.Length(); i++){
+        HandleScope Scope(Arguments.GetIsolate());
+        String::Utf8Value File(Arguments.GetIsolate(), Arguments[i]);
+        char const* CharFile = ToCString(File);
+        ExecutePythonFileFromNative(CharFile);
+    }
+}
\ No newline at end of file
diff --git a/src/objects/Console.hxx b/src/objects/Console.hxx
new file mode 100644
index 0000000..7b177e0
--- /dev/null
+++ b/src/objects/Console.hxx
@@ -0,0 +1,103 @@
+static void ConsoleLog(const FunctionCallbackInfo<Value>& Arguments){
+    for(unsigned short int i = 0; i < Arguments.Length(); i++){
+        HandleScope Scope(Arguments.GetIsolate());
+        if(i > 0) cout << " ";
+        String::Utf8Value Text(Arguments.GetIsolate(), Arguments[i]);
+        const char* CharText = ToCString(Text);
+        cout << CharText;
+    }
+    cout << endl;
+}
+
+static void ConsoleSetColor(const FunctionCallbackInfo<Value>& Arguments){
+    HandleScope Scope(Arguments.GetIsolate());
+    String::Utf8Value ColorIdentifier(Arguments.GetIsolate(), Arguments[0]);
+    const char* CharColorIdentifier = ToCString(ColorIdentifier);
+    cout << ConsoleColor(CharColorIdentifier);
+}
+
+static void ConsoleSetStyle(const FunctionCallbackInfo<Value>& Arguments){
+    HandleScope Scope(Arguments.GetIsolate());
+    String::Utf8Value StyleIdentifier(Arguments.GetIsolate(), Arguments[0]);
+    const char* CharStyleIdentifier = ToCString(StyleIdentifier);
+    cout << ConsoleStyle(CharStyleIdentifier);
+}
+
+static void ConsoleSetBackground(const FunctionCallbackInfo<Value>& Arguments){
+    HandleScope Scope(Arguments.GetIsolate());
+    String::Utf8Value BackgroundIdentifier(Arguments.GetIsolate(), Arguments[0]);
+    const char* CharBackgroundIdentifier = ToCString(BackgroundIdentifier);
+    cout << ConsoleBackground(CharBackgroundIdentifier);
+}
+
+static void ConsoleGetBackground(const FunctionCallbackInfo<Value>& Arguments){
+    HandleScope Scope(Arguments.GetIsolate());
+    String::Utf8Value BackgroundIdentifier(Arguments.GetIsolate(), Arguments[0]);
+    const char* CharBackgroundIdentifier = ToCString(BackgroundIdentifier);
+    string Background = ConsoleBackground(CharBackgroundIdentifier);
+    Arguments.GetReturnValue().Set(
+        String::NewFromUtf8(
+            Arguments.GetIsolate(),
+            Background.c_str(),
+            NewStringType::kNormal,
+            static_cast<int>(Background.length())
+        ).ToLocalChecked()
+    );
+}
+
+static void ConsoleGetStyle(const FunctionCallbackInfo<Value>& Arguments){
+    HandleScope Scope(Arguments.GetIsolate());
+    String::Utf8Value StyleIdentifier(Arguments.GetIsolate(), Arguments[0]);
+    const char* CharStyleIdentifier = ToCString(StyleIdentifier);
+    string Style = ConsoleStyle(CharStyleIdentifier);
+    Arguments.GetReturnValue().Set(
+        String::NewFromUtf8(
+            Arguments.GetIsolate(),
+            Style.c_str(),
+            NewStringType::kNormal,
+            static_cast<int>(Style.length())
+        ).ToLocalChecked()
+    );
+}
+
+static void ConsoleGetColor(const FunctionCallbackInfo<Value>& Arguments){
+    HandleScope Scope(Arguments.GetIsolate());
+    String::Utf8Value ColorIdentifier(Arguments.GetIsolate(), Arguments[0]);
+    const char* CharColorIdentifier = ToCString(ColorIdentifier);
+    string Color = ConsoleColor(CharColorIdentifier);
+    Arguments.GetReturnValue().Set(
+        String::NewFromUtf8(
+            Arguments.GetIsolate(),
+            Color.c_str(),
+            NewStringType::kNormal,
+            static_cast<int>(Color.length())
+        ).ToLocalChecked()
+    );
+}
+
+static void ConsoleClear(const FunctionCallbackInfo<Value>& Arguments){
+    HandleScope Scope(Arguments.GetIsolate());
+    ClearConsole();
+}
+        
+static void ConsoleInput(const FunctionCallbackInfo<Value>& Arguments){
+    for(unsigned short int i = 0; i < Arguments.Length(); i++){
+        HandleScope scope(Arguments.GetIsolate());
+        if(i > 0) cout << " ";
+        String::Utf8Value Text(Arguments.GetIsolate(), Arguments[i]);
+        const char* CharText = ToCString(Text);
+        cout << CharText;
+    }
+
+    string Response;
+    getline(cin, Response);
+
+    Arguments.GetReturnValue().Set(
+        String::NewFromUtf8(
+            Arguments.GetIsolate(),
+            Response.c_str(),
+            NewStringType::kNormal,
+            static_cast<int>(Response.length())
+        ).ToLocalChecked()
+    );
+}
\ No newline at end of file
diff --git a/src/objects/System.hxx b/src/objects/System.hxx
new file mode 100644
index 0000000..6d58524
--- /dev/null
+++ b/src/objects/System.hxx
@@ -0,0 +1,21 @@
+static void SystemExecute(const FunctionCallbackInfo<Value>& Arguments){
+    for(unsigned short int i = 0; i < Arguments.Length(); i++){
+        HandleScope Scope(Arguments.GetIsolate());
+        String::Utf8Value Command(Arguments.GetIsolate(), Arguments[i]);
+        const char* CharCommand = ToCString(Command);
+        system(CharCommand);
+    }
+}
+
+static void SystemPlatform(const FunctionCallbackInfo<Value>& Arguments){
+    HandleScope Scope(Arguments.GetIsolate());
+    string OS = OperativeSystem();
+    Arguments.GetReturnValue().Set(
+        String::NewFromUtf8(
+            Arguments.GetIsolate(),
+            OS.c_str(),
+            NewStringType::kNormal,
+            static_cast<int>(OS.length())
+        ).ToLocalChecked()
+    );
+}
\ No newline at end of file
diff --git a/src/Utility.hxx b/src/utils/Shared.hxx
similarity index 53%
rename from src/Utility.hxx
rename to src/utils/Shared.hxx
index 8901aff..bc7a599 100644
--- a/src/Utility.hxx
+++ b/src/utils/Shared.hxx
@@ -1,33 +1,9 @@
 #include <iostream>
-#include <algorithm>
-#include <vector>
-#include <fstream>
 #include <map>
+#include <fstream>
 #include <v8.h>
-#include <unistd.h>
-using namespace std;
 using namespace v8;
-
-const char* ZendaVersion = "1.0.1";
-
-const char* ZendaCreator = R"""(
- ______               _         ___ _____ 
-|___  /              | |       |_  /  ___|
-   / /  ___ _ __   __| | __ _    | \ `--.    | By Rodolfo Herrera Hernandez  
-  / /  / _ \ '_ \ / _` |/ _` |   | |`--. \   | Full Stack Developer
-./ /__|  __/ | | | (_| | (_| /\__/ /\__/ /   | https://github.com/rodiihernandezz/
-\_____/\___|_| |_|\__,_|\__,_\____/\____/         
-)""";
-
-string CurrentWorkingDirectory(){
-    char* cwd = getcwd(0,0);
-
-    string working_directory(cwd);
-    
-    free(cwd);
-    
-    return working_directory;
-}
+using namespace std;
 
 const char* OperativeSystem(){
     #if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
@@ -49,150 +25,68 @@ const char* OperativeSystem(){
     #endif
 }
 
+void ExecutePythonFileFromNative(const char* CharFile){
+    string BufferFileName = "";
+    string Command = "python3 " + BufferFileName.assign(CharFile);
+    system(Command.c_str());
+}
+
+void CreateFile(string FileName, string Content = ""){
+    ofstream OutFile(FileName);
+    if(Content.length())
+        OutFile << Content;
+    OutFile.close();
+}
+
+char* ReadFile(char Filename[]){
+    ifstream File;
+    File.open(Filename, ifstream::ate);
+    char* Contents;
+    if(!File){
+        Contents = new char[1];
+        return Contents;
+    }
+    size_t FileSize = File.tellg();
+    File.seekg(0);
+    filebuf* FileBuf = File.rdbuf();
+    Contents = new char[FileSize + 1]();
+    FileBuf->sgetn(Contents, FileSize);
+    File.close();
+    return Contents;
+}
+
 MaybeLocal<String> ReadFileUsingV8(const char* Filename, Isolate* LIsolate){
     FILE* File = fopen(Filename, "rb");
-
     if(File == NULL)
         return MaybeLocal<String>();
-
     fseek(File, 0, SEEK_END);
-
     size_t Size = ftell(File);
-
     rewind(File);
-
     char* Characters = new char[Size + 1];
-
     Characters[Size] = '\0';
-
     for(size_t i = 0; i < Size;){
         i += fread(&Characters[i], 1, Size - i, File);
-
         if(ferror(File)){
             fclose(File);
-                        
             return MaybeLocal<String>();
         }
     }
-
     fclose(File);
-
     MaybeLocal<String> Content = String::NewFromUtf8(
         LIsolate, Characters, NewStringType::kNormal, static_cast<int>(Size)
     );
-
     delete[] Characters;
-
     return Content;
 }
 
-char* ReadFile(char Filename[]){
-        ifstream File;
-
-        File.open(Filename, ifstream::ate);
-
-        char* Contents;
-
-        if(!File){
-            Contents = new char[1];
-            
-            return Contents;
-        }
-
-        size_t FileSize = File.tellg();
-
-        File.seekg(0);
-
-        filebuf* FileBuf = File.rdbuf();
-
-        Contents = new char[FileSize + 1]();
-
-        FileBuf->sgetn(Contents, FileSize);
-        
-        File.close();
-
-        return Contents;
-}
-
-const char* StringToLower(string String){
-    transform(String.begin(), String.end(), String.begin(), ::tolower);
-    return String.c_str();
-}
-
-const char* StringToUpper(string String){
-    transform(String.begin(), String.end(), String.begin(), ::toupper);
-    return String.c_str();
-}
-
 const char* ToCString(const String::Utf8Value& value) {
     return *value ? *value : "failed TOCSTRING.";
 }
 
-string StringStartAt(string String, unsigned int Position){
-    string Buffer;
-
-    while(String[Position])
-        Buffer += String[Position], Position++;
-
-    return Buffer;
-}
-
-string StringEndAt(string String, unsigned int Position){
-    string Buffer;
-
-    while(String[Position])
-        Buffer += String[Position], Position--;
-
-    return Buffer;
-}
-
-string StringStartEndAt(string String, unsigned int StartPosition, unsigned int EndPosition){
-    string Buffer;
-
-    while( (String[StartPosition]) && (StartPosition <= EndPosition) )
-        Buffer += String[StartPosition], StartPosition++;
-
-    return Buffer;
-}
-
-string StringLeftTrim(const string &String, string TrimCharacters = " \n\r\t\f\v"){
-	size_t Start = String.find_first_not_of(TrimCharacters);
-
-	return (Start == string::npos) ? "" : String.substr(Start);
-}
-
-string StringRightTrim(const string &String, string TrimCharacters = " \n\r\t\f\v"){
-	size_t End = String.find_last_not_of(TrimCharacters);
-
-	return (End == string::npos) ? "" : String.substr(0, End + 1);
-}
-
-string StringTrim(const string &String, string LeftTrimCharacters = " \n\r\t\f\v", string RightTrimCharacters = " \n\r\t\f\v"){
-	return StringRightTrim(StringLeftTrim(String, LeftTrimCharacters), RightTrimCharacters);
-}
-
-vector<string> SplitString(const string &str, const string &delim){
-    vector<string> tokens;
-    size_t prev = 0, pos = 0;
-    do{
-        pos = str.find(delim, prev);
-        if (pos == string::npos)
-            pos = str.length();
-        std::string token = str.substr(prev, pos - prev);
-        if (!token.empty())
-            tokens.push_back(StringTrim(token));
-        prev = pos + delim.length();
-    } while (pos < str.length() && prev < str.length());
-    return tokens;
-}
-
 const char* ConsoleBackground(string Background){
     map<string, string> Backgrounds;
- 
     map<string, string>::iterator BackgroundsIterator;
- 
     typedef pair<string, string> Pair;
- 
     Backgrounds.insert(Pair("black", "\33[40m"));
     Backgrounds.insert(Pair("red", "\33[41m"));
     Backgrounds.insert(Pair("green", "\33[42m"));
@@ -201,21 +95,16 @@ const char* ConsoleBackground(string Background){
     Backgrounds.insert(Pair("violet", "\33[45m"));
     Backgrounds.insert(Pair("beige", "\33[46m"));
     Backgrounds.insert(Pair("white", "\33[47m"));
- 
     BackgroundsIterator = Backgrounds.find(
         StringToLower(Background)
     );
-    
     return BackgroundsIterator != Backgrounds.end() ? BackgroundsIterator->second.c_str() :  "";
 }
 
 const char* ConsoleStyle(string Style){
     map<string, string> Styles;
-
     map<string, string>::iterator StylesIterator;
-
     typedef pair<string, string> Pair;
-
     Styles.insert(Pair("normal", "\33[0m"));
     Styles.insert(Pair("end", "\n"));
     Styles.insert(Pair("bold", "\33[1m"));
@@ -224,21 +113,16 @@ const char* ConsoleStyle(string Style){
     Styles.insert(Pair("blink", "\33[5m"));
     Styles.insert(Pair("blink2", "\33[6m"));
     Styles.insert(Pair("selected", "\33[7m"));
-
     StylesIterator = Styles.find(
         StringToLower(Style)
     );
-
     return StylesIterator != Styles.end() ? StylesIterator->second.c_str() :  "";
 }
 
 const char* ConsoleColor(string Color){
     map<string, string> Colors;
-
     map<string, string>::iterator ColorsIterator;
-
     typedef pair<string, string> Pair;
-
     Colors.insert(Pair("black", "\33[30m"));
     Colors.insert(Pair("red", "\33[31m"));
     Colors.insert(Pair("green", "\33[32m"));
@@ -248,23 +132,13 @@ const char* ConsoleColor(string Color){
     Colors.insert(Pair("beige", "\33[36m"));
     Colors.insert(Pair("white", "\33[37m"));
     Colors.insert(Pair("grey", "\33[90m"));
-
     ColorsIterator = Colors.find(
         StringToLower(Color)
     );
-
     return ColorsIterator != Colors.end() ? ColorsIterator->second.c_str() :  "";
 }
 
 void ClearConsole(){
     string OS = OperativeSystem();
     (OS == "WIN32") || (OS == "WIN64") ? system("cls") : system("clear");
-}
-
-void PrintVersion(){
-    cout << "ZendaJS v" << ZendaVersion << endl;
-}
-
-void PrintCreator(){
-    cout << ZendaCreator << endl;
 }
\ No newline at end of file
diff --git a/src/utils/String.hxx b/src/utils/String.hxx
new file mode 100644
index 0000000..0e9bf78
--- /dev/null
+++ b/src/utils/String.hxx
@@ -0,0 +1,74 @@
+#include <iostream>
+#include <algorithm>
+#include <vector>
+using namespace std;
+
+string RandomString(int n){
+    char letters[26] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
+    'r','s','t','u','v','w','x',
+    'y','z'};
+    string ran = "";
+    for (unsigned short int i = 0; i < n; i++) 
+        ran=ran + letters[rand() % 26];
+    return ran;
+}
+
+const char* StringToLower(string String){
+    transform(String.begin(), String.end(), String.begin(), ::tolower);
+    return String.c_str();
+}
+
+const char* StringToUpper(string String){
+    transform(String.begin(), String.end(), String.begin(), ::toupper);
+    return String.c_str();
+}
+
+string StringStartAt(string String, unsigned int Position){
+    string Buffer;
+    while(String[Position])
+        Buffer += String[Position], Position++;
+    return Buffer;
+}
+
+string StringEndAt(string String, unsigned int Position){
+    string Buffer;
+    while(String[Position])
+        Buffer += String[Position], Position--;
+    return Buffer;
+}
+
+string StringStartEndAt(string String, unsigned int StartPosition, unsigned int EndPosition){
+    string Buffer;
+    while( (String[StartPosition]) && (StartPosition <= EndPosition) )
+        Buffer += String[StartPosition], StartPosition++;
+    return Buffer;
+}
+
+string StringLeftTrim(const string &String, string TrimCharacters = " \n\r\t\f\v"){
+	size_t Start = String.find_first_not_of(TrimCharacters);
+	return (Start == string::npos) ? "" : String.substr(Start);
+}
+
+string StringRightTrim(const string &String, string TrimCharacters = " \n\r\t\f\v"){
+	size_t End = String.find_last_not_of(TrimCharacters);
+	return (End == string::npos) ? "" : String.substr(0, End + 1);
+}
+
+string StringTrim(const string &String, string LeftTrimCharacters = " \n\r\t\f\v", string RightTrimCharacters = " \n\r\t\f\v"){
+	return StringRightTrim(StringLeftTrim(String, LeftTrimCharacters), RightTrimCharacters);
+}
+
+vector<string> SplitString(const string &str, const string &delim){
+    vector<string> tokens;
+    size_t prev = 0, pos = 0;
+    do{
+        pos = str.find(delim, prev);
+        if (pos == string::npos)
+            pos = str.length();
+        std::string token = str.substr(prev, pos - prev);
+        if (!token.empty())
+            tokens.push_back(StringTrim(token));
+        prev = pos + delim.length();
+    } while (pos < str.length() && prev < str.length());
+    return tokens;
+}
\ No newline at end of file