diff --git a/vulkust/src/render/model/mod.rs b/vulkust/src/render/model/mod.rs
@@ -7,7 +7,10 @@ use super::super::math::matrix::Mat4x4;
 use super::super::system::os::OsApplication;
 use super::super::system::file::File;
 use super::buffer::Buffer;
+use super::shader::manager::Manager as ShaderManager;
+use super::texture::manager::Manager as TextureManager;
 use super::mesh::Mesh;
+use self::manager::Manager;
 
 pub trait Model {}
 
@@ -17,19 +20,21 @@ pub struct StaticModel {
 }
 
 impl StaticModel {
-    pub fn new<CoreApp>(
+    pub fn new(
         file: &mut File,
-        os_app: &mut OsApplication<CoreApp>,
+        model_manager: &mut Manager,
         vertices_buffer: &mut Buffer,
-        indices_buffer: &mut Buffer) -> Self
-    where
-        CoreApp: ApplicationTrait,
-    {
-        let mesh = Mesh::new(file, os_app, vertices_buffer, indices_buffer);
+        indices_buffer: &mut Buffer,
+        texture_manager: &mut TextureManager,
+        shader_manager: &mut ShaderManager,
+    ) -> Self {
+        let mesh = Mesh::new(file, vertices_buffer, indices_buffer);
         let children_count: u64 = file.read_type();
         let mut children = Vec::new();
         for _ in 0..children_count {
-            children.push(read_boxed_model(file, os_app, vertices_buffer, indices_buffer));
+            children.push(read_boxed_model(
+                file, model_manager, vertices_buffer, indices_buffer,
+                texture_manager, shader_manager));
         }
         StaticModel {
             draw_mesh: mesh,
@@ -47,19 +52,22 @@ pub struct DynamicModel {
 }
 
 impl DynamicModel {
-    pub fn new<CoreApp>(
-        file: &mut File, os_app: &mut OsApplication<CoreApp>,
+    pub fn new(
+        file: &mut File,
+        model_manager: &mut Manager,
         vertices_buffer: &mut Buffer,
-        indices_buffer: &mut Buffer) -> Self
-    where
-        CoreApp: ApplicationTrait,
-    {
+        indices_buffer: &mut Buffer,
+        texture_manager: &mut TextureManager,
+        shader_manager: &mut ShaderManager,
+    ) -> Self {
         let m = Mat4x4::new_from_file(file);
-        let mesh = Mesh::new(file, os_app, vertices_buffer, indices_buffer);
+        let mesh = Mesh::new(file, vertices_buffer, indices_buffer);
         let children_count: u64 = file.read_type();
         let mut children = Vec::new();
         for _ in 0..children_count {
-            children.push(read_boxed_model(file, os_app, vertices_buffer, indices_buffer));
+            children.push(read_boxed_model(
+                file, model_manager, vertices_buffer, indices_buffer,
+                texture_manager, shader_manager));
         }
         DynamicModel {
             transform: m,
@@ -77,56 +85,65 @@ pub struct CopyModel {
 }
 
 impl CopyModel {
-    pub fn new<CoreApp>(
-        file: &mut File, os_app: &mut OsApplication<CoreApp>,
+    pub fn new(
+        file: &mut File,
+        model_manager: &mut Manager,
         vertices_buffer: &mut Buffer,
-        indices_buffer: &mut Buffer) -> Self
-    where
-        CoreApp: ApplicationTrait,
-    {
+        indices_buffer: &mut Buffer,
+        texture_manager: &mut TextureManager,
+        shader_manager: &mut ShaderManager,
+    ) -> Self {
         let t = Mat4x4::new_from_file(file);
         let id = file.read_id();
         CopyModel {
             t: t,
-            sm: os_app.asset_manager.get_model(id, os_app, vertices_buffer, indices_buffer),
+            sm: model_manager.get(
+                id, file, vertices_buffer, indices_buffer, texture_manager, shader_manager),
         }
     }
 }
 
 impl Model for CopyModel {}
 
-pub fn read_model<CoreApp>(
+pub fn read_model(
     file: &mut File,
-    os_app: &mut OsApplication<CoreApp>,
+    model_manager: &mut Manager,
     vertices_buffer: &mut Buffer,
     indices_buffer: &mut Buffer,
-) -> Arc<RefCell<Model>>
-where
-    CoreApp: ApplicationTrait,
-{
+    texture_manager: &mut TextureManager,
+    shader_manager: &mut ShaderManager,
+) -> Arc<RefCell<Model>> {
     return if file.read_bool() {
-        Arc::new(RefCell::new(CopyModel::new(file, os_app, vertices_buffer, indices_buffer)))
+        Arc::new(RefCell::new(CopyModel::new(
+            file, model_manager, vertices_buffer,
+            indices_buffer, texture_manager, shader_manager)))
     } else if file.read_bool() {
-        Arc::new(RefCell::new(DynamicModel::new(file, os_app, vertices_buffer, indices_buffer)))
+        Arc::new(RefCell::new(DynamicModel::new(
+            file, model_manager, vertices_buffer,
+            indices_buffer, texture_manager, shader_manager)))
     } else {
-        Arc::new(RefCell::new(StaticModel::new(file, os_app, vertices_buffer, indices_buffer)))
+        Arc::new(RefCell::new(StaticModel::new(
+            file, model_manager, vertices_buffer,
+            indices_buffer, texture_manager, shader_manager)))
     };
 }
 
-fn read_boxed_model<CoreApp>(
+fn read_boxed_model(
     file: &mut File,
-    os_app: &mut OsApplication<CoreApp>,
+    model_manager: &mut Manager,
     vertices_buffer: &mut Buffer,
     indices_buffer: &mut Buffer,
-) -> Box<Model>
-where
-    CoreApp: ApplicationTrait,
-{
+    texture_manager: &mut TextureManager,
+    shader_manager: &mut ShaderManager,
+) -> Box<Model> {
     return if file.read_bool() {
-        Box::new(CopyModel::new(file, os_app, vertices_buffer, indices_buffer))
+        Box::new(CopyModel::new(
+            file, model_manager, vertices_buffer, indices_buffer, texture_manager, shader_manager))
     } else if file.read_bool() {
-        Box::new(DynamicModel::new(file, os_app, vertices_buffer, indices_buffer))
+        Box::new(DynamicModel::new(
+            file, model_manager, vertices_buffer, indices_buffer, texture_manager, shader_manager))
     } else {
-        Box::new(StaticModel::new(file, os_app, vertices_buffer, indices_buffer))
+        Box::new(StaticModel::new(
+            file, model_manager, vertices_buffer, indices_buffer, texture_manager, shader_manager))
     };
 }
diff --git a/vulkust/src/render/scene/manager.rs b/vulkust/src/render/scene/manager.rs
@@ -2,9 +2,24 @@ use std::cell::RefCell;
 use std::collections::BTreeMap;
 use std::sync::{Arc, Weak};
 use std::io::{Seek, SeekFrom};
+use std::mem::transmute;
 use super::super::super::core::application::ApplicationTrait;
 use super::super::super::system::os::OsApplication;
 use super::super::super::system::file::File;
+use super::super::super::audio::Audio;
+use super::super::super::audio::manager::Manager as AudioManager;
+use super::super::buffer::{Buffer, Usage as BufferUsage};
+use super::super::buffer::uniform::Uniform;
+use super::super::camera::Camera;
+use super::super::camera::manager::Manager as CameraManager;
+use super::super::camera::perspective::Perspective;
+use super::super::command::pool::Pool as CmdPool;
+use super::super::light::Light;
+use super::super::light::manager::Manager as LightManager;
+use super::super::model::Model;
+use super::super::model::manager::Manager as ModelManager;
+use super::super::shader::manager::Manager as ShaderManager;
+use super::super::texture::manager::Manager as TextureManager;
 use super::{BasicScene, Scene};
 
 pub struct Manager {
@@ -28,15 +43,19 @@ impl Manager {
         }
     }
 
-    pub fn get<CoreApp>(
+    pub fn get(
         &mut self,
         id: u64,
         file: &mut File,
-        os_app: &mut OsApplication<CoreApp>,
-    ) -> Arc<RefCell<Scene>>
-    where
-        CoreApp: ApplicationTrait,
-    {
+        camera_manager: &mut CameraManager,
+        audio_manager: &mut AudioManager,
+        light_manager: &mut LightManager,
+        model_manager: &mut ModelManager,
+        shader_manager: &mut ShaderManager,
+        texture_manager: &mut TextureManager,
+        screen_ratio: f32,
+        transfer_cmd_pool: Arc<CmdPool>
+    ) -> Arc<RefCell<Scene>> {
         match self.cached.get(&id) {
             Some(res) => match res.upgrade() {
                 Some(res) => {
@@ -55,7 +74,9 @@ impl Manager {
                 logf!("Can not seek to the requested offset.");
             }
         }
-        let scene = RefCell::new(BasicScene::new(file, os_app));
+        let scene = RefCell::new(BasicScene::new(
+            file, camera_manager, audio_manager, light_manager, model_manager, shader_manager,
+            texture_manager, screen_ratio, transfer_cmd_pool));
         let scene: Arc<RefCell<Scene>> = Arc::new(scene);
         self.cached.insert(id, Arc::downgrade(&scene));
         return scene;

diff --git a/vulkust/src/render/scene/mod.rs b/vulkust/src/render/scene/mod.rs
@@ -4,15 +4,22 @@ use std::cell::RefCell;
 use std::mem::transmute;
 use std::sync::Arc;
 use super::super::audio::Audio;
+use super::super::audio::manager::Manager as AudioManager;
 use super::super::core::application::ApplicationTrait;
 use super::super::system::os::OsApplication;
 use super::super::system::file::File;
 use super::buffer::{Buffer, Usage as BufferUsage};
 use super::buffer::uniform::Uniform;
 use super::camera::Camera;
+use super::camera::manager::Manager as CameraManager;
 use super::camera::perspective::Perspective;
+use super::command::pool::Pool as CmdPool;
 use super::light::Light;
+use super::light::manager::Manager as LightManager;
 use super::model::Model;
+use super::model::manager::Manager as ModelManager;
+use super::shader::manager::Manager as ShaderManager;
+use super::texture::manager::Manager as TextureManager;
 
 pub trait Scene {
     fn get_current_camera(&self) -> &Arc<RefCell<Camera<f32>>>;
@@ -30,50 +37,50 @@ pub struct BasicScene {
 }
 
 impl BasicScene {
-    pub fn new<CoreApp>(file: &mut File, os_app: &mut OsApplication<CoreApp>) -> Self
-    where
-        CoreApp: ApplicationTrait,
-    {
-        let cmd_pool = unsafe {
-            (*(*os_app).render_engine)
-                .transfer_cmd_pool
-                .as_ref()
-                .unwrap()
-                .clone()
-        };
-        let device = cmd_pool.logical_device.clone();
-        let asset_manager = &mut os_app.asset_manager;
+    pub fn new(
+        file: &mut File,
+        camera_manager: &mut CameraManager,
+        audio_manager: &mut AudioManager,
+        light_manager: &mut LightManager,
+        model_manager: &mut ModelManager,
+        shader_manager: &mut ShaderManager,
+        texture_manager: &mut TextureManager,
+        screen_ratio: f32,
+        transfer_cmd_pool: Arc<CmdPool>) -> Self {
+        let device = transfer_cmd_pool.logical_device.clone();
         let v_size = file.read_type::<u64>() * 1024;
         let i_size = file.read_type::<u64>() * 1024;
         let mut meshes_vertices_buffer =
-            Buffer::new(cmd_pool.clone(), v_size, BufferUsage::Vertex);
+            Buffer::new(transfer_cmd_pool.clone(), v_size, BufferUsage::Vertex);
         let mut meshes_indices_buffer =
-            Buffer::new(cmd_pool.clone(), i_size, BufferUsage::Index);
+            Buffer::new(transfer_cmd_pool.clone(), i_size, BufferUsage::Index);
         let uniform_buffer = Uniform::new(device, 1024);
         let cameras_count: u64 = file.read_type();
         let mut cameras = Vec::new();
         for _ in 0..cameras_count {
             let id: u64 = file.read_type();
-            cameras.push(asset_manager.get_camera(id, os_app));
+            cameras.push(camera_manager.get(id, file, screen_ratio));
         }
         let audios_count: u64 = file.read_type();
         let mut audios = Vec::new();
         for _ in 0..audios_count {
             let id: u64 = file.read_type();
-            audios.push(asset_manager.get_audio(id, os_app));
+            audios.push(audio_manager.get(id, file));
         }
         let lights_count: u64 = file.read_type();
         let mut lights = Vec::new();
         for _ in 0..lights_count {
             let id: u64 = file.read_type();
-            lights.push(asset_manager.get_light(id, os_app));
+            lights.push(light_manager.get(id, file));
         }
         let models_count: u64 = file.read_type();
         let mut models = Vec::new();
         for _ in 0..models_count {
             let id: u64 = file.read_type();
-            models.push(asset_manager.get_model(
-                id, os_app, &mut meshes_vertices_buffer, &mut meshes_indices_buffer));
+            models.push(model_manager.get(
+                id, file,
+                &mut meshes_vertices_buffer, &mut meshes_indices_buffer,
+                texture_manager, shader_manager));
         }
         BasicScene {
             meshes_vertices_buffer: meshes_vertices_buffer,

diff --git a/vulkust/src/render/texture/manager.rs b/vulkust/src/render/texture/manager.rs
@@ -1,9 +1,7 @@
 use std::collections::BTreeMap;
 use std::sync::{Arc, Weak};
 use std::io::{Seek, SeekFrom};
-use super::super::super::core::application::ApplicationTrait;
 use super::super::super::system::file::File;
-use super::super::super::system::os::OsApplication;
 use super::{Texture2D, Texture, Id};
 
 #[derive(Debug)]
@@ -28,15 +26,7 @@ impl Manager {
         }
     }
 
-    pub fn get<CoreApp>(
-        &mut self,
-        id: Id,
-        file: &mut File,
-        os_app: *mut OsApplication<CoreApp>,
-    ) -> Arc<Texture>
-    where
-        CoreApp: ApplicationTrait,
-    {
+    pub fn get(&mut self, id: Id, file: &mut File) -> Arc<Texture> {
         match self.cached.get(&id) {
             Some(res) => match res.upgrade() {
                 Some(res) => {
@@ -56,7 +46,7 @@ impl Manager {
             }
         }
         let texture = match id {
-            1 => Texture2D::new(file, os_app),
+            1 => Texture2D::new(file),
             _ => {
                 logf!("Requsted texture Id: {} not found.", id);
             }

diff --git a/vulkust/src/render/texture/mod.rs b/vulkust/src/render/texture/mod.rs
@@ -2,8 +2,6 @@ pub mod manager;
 
 use std::fmt::Debug;
 use super::super::system::file::File;
-use super::super::system::os::OsApplication;
-use super::super::core::application::ApplicationTrait;
 #[cfg(metal)]
 use super::super::metal::texture::Texture2D as PlatformTexture2D;
 #[cfg(vulkan)]
@@ -27,15 +25,12 @@ pub struct Texture2D {
 }
 
 impl Texture2D {
-    pub fn new<CoreApp>(file: &mut File, os_app: *mut OsApplication<CoreApp>) -> Self
-    where
-        CoreApp: ApplicationTrait,
-    {
+    pub fn new(file: &mut File) -> Self {
         let size: u64 = file.read_type();
         // logi!("Texture2D size is: {}", size);
         let data = file.read_bytes(size as usize);
         Texture2D {
-            raw: PlatformTexture2D::new(data, os_app),
+            raw: PlatformTexture2D::new(data),
         }
     }
 }

diff --git a/vulkust/src/vulkan/texture/mod.rs b/vulkust/src/vulkan/texture/mod.rs
@@ -1,16 +1,11 @@
 use super::super::core::application::ApplicationTrait;
-use super::super::system::os::OsApplication;
 
 // TODO
-
 #[derive(Debug)]
 pub struct Texture2D {}
 
 impl Texture2D {
-    pub fn new<CoreApp>(_data: Vec<u8>, _os_app: *mut OsApplication<CoreApp>) -> Self
-    where
-        CoreApp: ApplicationTrait,
-    {
+    pub fn new(_data: Vec<u8>) -> Self {
         Texture2D {}
     }
 }