More work on installation stage

Cargo.toml

@@ -9,19 +9,19 @@ edition = "2024"
 [dependencies]
 blocking = "1.6"
 iced = { version = "0.14", default-features = false, features = ["crisp", "linux-theme-detection", "tiny-skia", "x11", "smol", "image"] }
+#iced = { git = "https://github.com/iced-rs/iced", branch = "vello_cpu", default-features = false, features = ["crisp", "linux-theme-detection", "vello-cpu", "x11", "smol", "image"]}
 iced_moving_picture = "0"
 log = "0.4"
 rust-i18n = "3"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 time-format = "1.2"
-toml = "1"
 
 [dev-dependencies]
 rand = "0.10"
 
 [profile.dev]
-opt-level = 2
+opt-level = 3
 codegen-units = 16
 
 [profile.release]
@@ -29,6 +29,11 @@ lto = true
 debug = false
 incremental = false
 codegen-units = 1
+# We need level 3 for tiny-skia otherwise render is lagging 
+# opt-level = "s"
 opt-level = 3
 strip = true
 
+
+[registry]
+global-min-publish-age = "14 days"

src/kira_config.toml

@@ -4,3 +4,4 @@ reqire_network = true
 
 [partition]
 min_disk_size_mb = 8192
+efi_size_mb = 128

src/kira_disk_layout.rs

@@ -18,9 +18,9 @@
    Functions for working with disk layout
 */
 
+use crate::kira_size::KiraSize;
 use log;
 use std::collections::HashMap;
-use crate::kira_size::{KiraSize};
 ///
 /// size - device size in bytes
 /// sector size - default 4096
@@ -38,6 +38,7 @@ impl std::fmt::Display for BlkDev {
 }
 
 impl BlkDev {
+    /// Create new BlkDev struct with specifyed name and size
     pub fn new(name: String, size: KiraSize) -> Self {
         Self {
             name: name,
@@ -45,6 +46,9 @@ impl BlkDev {
             sector_size: KiraSize::new_b(4096),
         }
     }
+
+    /// Create new BlkDev struct with name and size parsed from hashmap
+    /// that contains String key val pairs with "NAME" and "SIZE" keys
     pub fn from_hash_map(data: &HashMap<String, String>) -> Option<Self> {
         Some(Self {
             name: data.get("NAME")?.clone(),
@@ -52,7 +56,13 @@ impl BlkDev {
             sector_size: KiraSize::new_b(4096),
         })
     }
+    /// returns dev name in a "/dev/name" form
+    pub fn full_name(&self) -> String {
+        format!("/dev/{}", self.name)
+    }
+
     /// this is blocking function
+    /// Lists block devices in system thru "lsbk" command
     pub fn list_sys_blk_dev() -> Result<Vec<Self>, String> {
         use std::process::Command;
 
@@ -96,6 +106,36 @@ impl BlkDev {
             Err(ex) => Err(ex.to_string()),
         }
     }
+
+    pub fn from_sys(name: &str) -> Option<Self> {
+        Self::list_sys_blk_dev()
+            .ok()?
+            .iter()
+            .find(|v| v.name == name)
+            .cloned()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BcachefsProp {
+    pub password: Option<String>,
+    pub comp_alg: Option<String>,
+}
+
+impl BcachefsProp {
+    pub fn new(password: Option<String>, comp_alg: Option<String>) -> Self {
+        Self {
+            password: password,
+            comp_alg: comp_alg,
+        }
+    }
+
+    pub fn default() -> Self {
+        Self {
+            password: None,
+            comp_alg: None,
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -106,7 +146,7 @@ pub enum FSType {
     SWAP,
     EXT4,
     BTRFS,
-    BCACHEFS,
+    BCACHEFS(BcachefsProp),
     UNKNOWN,
 }
 
@@ -119,7 +159,7 @@ impl std::fmt::Display for FSType {
             Self::SWAP => write!(f, "swap"),
             Self::EXT4 => write!(f, "ext4"),
             Self::BTRFS => write!(f, "btrfs"),
-            Self::BCACHEFS => write!(f, "bcachefs"),
+            Self::BCACHEFS(_) => write!(f, "bcachefs"),
             Self::UNKNOWN => write!(f, "unknown"),
         }
     }
@@ -135,10 +175,26 @@ impl FSType {
             "swap" => Self::SWAP,
             "ext4" => Self::EXT4,
             "btrfs" => Self::BTRFS,
-            "bcachefs" => Self::BCACHEFS,
+            "bcachefs" => Self::BCACHEFS(BcachefsProp::default()),
             _ => Self::UNKNOWN,
         }
     }
+
+    /// return fs type that can be used with parted utility
+    pub fn to_parted_str(&self) -> &str {
+        match self {
+            Self::VFAT => "fat32",
+            Self::XFS => "xfs",
+            Self::LUKS => "luks",
+            Self::SWAP => "linux-swap",
+            Self::EXT4 => "ext4",
+            Self::BTRFS => "btrfs",
+            // workaroud as parted do not support bcachefs partition type
+            Self::BCACHEFS(_) => "xfs",
+            // lets do something generic here instead of panic
+            Self::UNKNOWN => "linux-swap",
+        }
+    }
 }
 
 // fn part_type_to_color(t: &str) -> Color {
@@ -157,10 +213,7 @@ impl FSType {
 pub enum PartRole {
     EFI,
     ROOT,
-    HOME,
     SWAP,
-    LuksRoot,
-    LuksHome,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -177,17 +230,27 @@ pub struct PartInfo {
 
 impl std::fmt::Display for PartInfo {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{} {} {}",
-            &self.name,
-            &self.fs_type,
-            self.size
-        )
+        write!(f, "{} {} {}", &self.name, &self.fs_type, self.size)
     }
 }
 
 impl PartInfo {
+    ///
+    ///  calculate par end byte as 0 starting bytes index (for parted and such)
+    ///
+    pub fn part_end(&self) -> KiraSize {
+        // important to shift here by 1 because disk index is starting from 0, and part end pointing to last byte of the partition.
+        (self.start + self.size) - KiraSize::new_b(1)
+    }
+
+    ///
+    /// Returns zero based byte index of start of next (right after this one) partition
+    ///
+    pub fn next_part_start(&self) -> KiraSize {
+        // important to shift here by 1 because disk index is starting from 0, and part end pointing to last byte of the partition.
+        self.start + self.size
+    }
+
     pub fn from_hash_map(data: &HashMap<String, String>) -> Option<Self> {
         Some(Self {
             name: data.get("NAME")?.clone(),
@@ -206,6 +269,12 @@ impl PartInfo {
             role: None,
         })
     }
+
+    pub fn partlabel_dev(&self) -> Option<String> {
+        self.gpt_label
+            .as_ref()
+            .and_then(|l| Some(format!("/dev/disk/by-partlabel/{}", l)))
+    }
 }
 
 /// getting list of device partitions
@@ -214,9 +283,11 @@ fn get_dev_part_blocking(dev_name: &str) -> Result<Vec<PartInfo>, String> {
 
     //"lsblk -o NAME,SIZE,FSTYPE -l -n  /dev/nvme0n1"
     // lsblk -o NAME,SIZE,FSTYPE,TYPE,PARTLABEL,LABEL,PARTFLAGS -b -P
-
+    // -x NAME - sorting by name
     match Command::new("lsblk")
         .args([
+            "-x",
+            "NAME",
             "-o",
             "NAME,SIZE,FSTYPE,TYPE,PARTLABEL,LABEL,MOUNTPOINT,PARTFLAGS",
             "-b",
@@ -283,7 +354,7 @@ pub fn align_part(size: u64, start: u64, align: u64) -> Option<(u64, u64, u64)>
     // decreasing end if not align
     let part_end = align_start + size;
     let end_mod = part_end % align;
-    log::debug!("part_end: {} end_mod: {}", part_end, end_mod);
+
     let align_end = part_end - end_mod - 1;
 
     let align_size = align_end - align_start + 1;
@@ -291,24 +362,39 @@ pub fn align_part(size: u64, start: u64, align: u64) -> Option<(u64, u64, u64)>
     if align_size < align {
         log::warn!(
             "!!! align_size < align !!! align_size: {} align: {}",
-            align_size, align
+            align_size,
+            align
         );
         return None;
     }
-
+    log::debug!(
+        "align_size: {}, align_start:{}, align_end: {} end_mod: {}",
+        align_size,
+        align_start,
+        align_end,
+        end_mod
+    );
     Some((align_size, align_start, align_end))
 }
 
+#[derive(Debug, Clone, PartialEq)]
 pub struct PartLayout {
     pub dev: BlkDev,
     pub empty_space: KiraSize,
     pub part_list: Vec<PartInfo>,
 }
 
+///
+/// GPT requires 33x512 sectors at the very end of the disk (16896 bytes):
+/// 32 sectors - backup Partition Entry Array
+/// 1 sector - backup GPT header
+///
 impl PartLayout {
     pub fn new(dev: BlkDev) -> Self {
+        // 16896 - reserved space at the dev end for gpt
+        let usable_space = dev.size - KiraSize::new_b(16896);
         Self {
-            empty_space: dev.size,
+            empty_space: usable_space,
             dev: dev,
             part_list: Vec::new(),
         }
@@ -316,7 +402,9 @@ impl PartLayout {
 
     pub fn read_from_disk(dev: &BlkDev) -> Result<Self, String> {
         let part_list = get_dev_part_blocking(&dev.name)?;
-        let parts_size = part_list.iter().fold(KiraSize::new_b(0), |acc, part| acc + part.size);
+        let parts_size = part_list
+            .iter()
+            .fold(KiraSize::new_b(0), |acc, part| acc + part.size);
         Ok(Self {
             dev: dev.clone(),
             empty_space: dev.size - parts_size,
@@ -324,11 +412,11 @@ impl PartLayout {
         })
     }
 
-    pub fn new_table(mut self) -> Self {
-        self.empty_space = self.dev.size;
-        self.part_list = Vec::new();
-        self
-    }
+    // pub fn new_table(mut self) -> Self {
+    //     self.empty_space = self.dev.size;
+    //     self.part_list = Vec::new();
+    //     self
+    // }
 
     pub fn add_part(
         mut self,
@@ -340,19 +428,29 @@ impl PartLayout {
         role: Option<PartRole>,
     ) -> Self {
         let part_start = if self.part_list.is_empty() {
+            // need to substract 2 mb offset from disk start.
+            self.empty_space = self.empty_space - KiraSize::new_mb(2);
             KiraSize::new_mb(2)
         } else {
-            self.dev.size - self.empty_space
+            // last part end + 1
+            self.part_list.last().unwrap().next_part_start()
         };
 
-        let (size, start, _) =
+        let (a_size, a_start, _) =
             align_part(part_size.b(), part_start.b(), self.dev.sector_size.b()).unwrap();
 
+        log::debug!(
+            "PartLayout.add_part gpt_label{:?}, size_asked:{}, size_al:{}",
+            gpt_label,
+            part_size,
+            a_size
+        );
+
         let part_name = format!("{}p{}", self.dev.name, self.part_list.len() + 1);
         self.part_list.push(PartInfo {
             name: part_name,
-            size: KiraSize::new_b(size),
-            start: KiraSize::new_b(start),
+            size: KiraSize::new_b(a_size),
+            start: KiraSize::new_b(a_start),
             fs_type: fs_type,
             gpt_label: gpt_label,
             fs_label: fs_label,
@@ -360,10 +458,14 @@ impl PartLayout {
             role: role,
         });
 
-        self.empty_space = self.empty_space - KiraSize::new_b(size);
+        self.empty_space = self.empty_space - KiraSize::new_b(a_size);
 
         self
     }
+    ///
+    /// Use this to add partition of (disk_empty_space - reserve_space)
+    /// Specifically to leave some space at the end for SWAP and such
+    ///
     pub fn add_part_reserve(
         self,
         reserve_space: KiraSize,
@@ -377,7 +479,13 @@ impl PartLayout {
         self.add_part(p_size, fs_type, gpt_label, fs_label, mount_point, role)
     }
 
-    pub fn gen_classic_layout(dev: BlkDev, efi_size: KiraSize, swap_size: KiraSize) -> Self {
+    pub fn gen_kira_layout(
+        dev: BlkDev,
+        efi_size: KiraSize,
+        swap_size: KiraSize,
+        maybe_password: Option<String>,
+        maybe_compr: Option<String>,
+    ) -> Self {
         let mut res: PartLayout = PartLayout::new(dev);
 
         // UEFI partition
@@ -385,15 +493,15 @@ impl PartLayout {
             .add_part(
                 efi_size,
                 FSType::VFAT,
-                Some("efi".into()),
+                Some("bee-efi".into()),
                 Some("EFI".into()),
-                Some("/efi".into()),
+                Some("/beefi".into()),
                 Some(PartRole::EFI),
             )
             .add_part_reserve(
                 swap_size,
-                FSType::XFS,
-                Some("root".into()),
+                FSType::BCACHEFS(BcachefsProp::new(maybe_password, maybe_compr)),
+                Some("bee-root".into()),
                 None,
                 Some("/".into()),
                 Some(PartRole::ROOT),
@@ -404,7 +512,7 @@ impl PartLayout {
             res = res.add_part(
                 swap_size,
                 FSType::SWAP,
-                Some("swap".into()),
+                Some("bee-swap".into()),
                 None,
                 Some("SWAP".into()),
                 Some(PartRole::SWAP),
@@ -466,4 +574,3 @@ mod tests {
         }
     }
 }
-

src/kira_size.rs

@@ -46,6 +46,13 @@ impl std::fmt::Display for KiraSize {
 
 impl KiraSize {
     pub const SUFFIXS: [&str; 5] = ["KB", "MB", "GB", "TB", "PB"];
+
+    /// returns size in bytes suffixed with "B" character
+    pub fn to_parted_bytes_str(&self)-> String {
+        format!("{}B", self.size_bytes)
+    }
+
+
     pub fn new_b(size:u64) -> Self {
         Self { size_bytes: size }
     }

src/kira_system.rs

@@ -0,0 +1,332 @@
+// <Kira Installer - universal Linux installer.>
+// Copyright (C) <2026>  <Kira Foundation>
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+/*
+   Functions for creating with disk layout
+*/
+
+use crate::kira_disk_layout::*;
+use crate::kira_size::KiraSize;
+use std::fs;
+use std::process::Command;
+
+#[derive(Debug)]
+pub struct CommandFailed {
+    stderr: Vec<u8>,
+    cmd: String,
+}
+
+impl std::fmt::Display for CommandFailed {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(
+            f,
+            "Command failed! Command: {}; Stderr: {}",
+            self.cmd,
+            String::from_utf8(self.stderr.clone())
+                .unwrap_or_else(|_| { "STDEER IS NOT VALID UTF-8".to_string() })
+        )
+    }
+}
+
+impl CommandFailed {
+    pub fn new(cmd: &str, args: &Vec<&str>, stderr: Vec<u8>) -> Self {
+        Self {
+            stderr: stderr,
+            cmd: format!("{} {}", cmd, args.join(" ")),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum ExecCommandError {
+    IoError(std::io::Error),
+    FromUtf8Error(std::string::FromUtf8Error),
+    CommandFailed(CommandFailed),
+    Other(String),
+}
+
+// 2. Implement From for each wrapped error type
+impl From<std::io::Error> for ExecCommandError {
+    fn from(err: std::io::Error) -> Self {
+        ExecCommandError::IoError(err)
+    }
+}
+
+impl From<std::string::FromUtf8Error> for ExecCommandError {
+    fn from(err: std::string::FromUtf8Error) -> Self {
+        ExecCommandError::FromUtf8Error(err)
+    }
+}
+
+impl From<CommandFailed> for ExecCommandError {
+    fn from(err: CommandFailed) -> Self {
+        ExecCommandError::CommandFailed(err)
+    }
+}
+
+impl From<String> for ExecCommandError {
+    fn from(err: String) -> Self {
+        ExecCommandError::Other(err)
+    }
+}
+
+impl std::fmt::Display for ExecCommandError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            ExecCommandError::IoError(e) => write!(f, "IO Error: {}", e),
+            ExecCommandError::FromUtf8Error(e) => {
+                write!(f, "IO streem to String parse Error: {}", e)
+            }
+            ExecCommandError::CommandFailed(ex) => {
+                write!(f, "{}", ex)
+            }
+            ExecCommandError::Other(msg) => write!(f, "Error: {}", msg),
+        }
+    }
+}
+
+// Implement std::error::Error
+impl std::error::Error for ExecCommandError {}
+
+/// exec given sommand with arguments, capturing stderr in case or failure
+fn exec_command(cmd: &str, args: &Vec<&str>) -> Result<(), ExecCommandError> {
+    let out = Command::new(cmd).args(args).output()?;
+    if out.status.success() {
+        Ok(())
+    } else {
+        Err(CommandFailed::new(cmd, args, out.stderr).into())
+    }
+}
+
+/// exec given sommand with arguments, returning stdout parsed to UTF-8 string
+/// capturing stderr in case or failure
+fn exec_command_out(cmd: &str, args: &Vec<&str>) -> Result<String, ExecCommandError> {
+    let out = Command::new(cmd).args(args).output()?;
+    if out.status.success() {
+        Ok(String::from_utf8(out.stdout)?)
+    } else {
+        Err(CommandFailed::new(cmd, args, out.stderr).into())
+    }
+}
+
+/// sync system time with chrony
+/// dinitctl start chrony
+pub fn dinit_sync_time_chrony() -> Result<(), ExecCommandError> {
+    exec_command("dinitctl", &vec!["start", "chrony"])
+}
+
+/// Install base system
+/// basestrap /mnt base base-devel dinit elogind-dinit
+pub fn basestrap_dinit(root_dir: &str) -> Result<(), ExecCommandError> {
+    exec_command(
+        "basestrap",
+        &vec![root_dir, "base", "base-devel", "dinit", "elogind-dinit"],
+    )
+}
+
+/// Executes parted command with given arguments
+fn exec_parted(args: &Vec<&str>) -> Result<String, ExecCommandError> {
+    exec_command_out("parted", args)
+}
+
+fn parted_get_last_part_num(dev: &BlkDev) -> Result<u32, ExecCommandError> {
+    // parted -m /dev/loop0 print
+    let res = exec_parted(&vec!["-m", dev.full_name().as_str(), "print"])?;
+
+    match res.lines().last().and_then(|last_line| {
+        last_line
+            .split_once(':')
+            .and_then(|(first_part, _)| u32::from_str_radix(first_part, 10).ok())
+    }) {
+        Some(n) => Ok(n),
+        None => Err("Error parsing parted output".to_string().into()),
+    }
+}
+
+/// init gpt partition table
+/// parted --script $install_device  mklabel gpt
+/// Its blocking function
+pub fn parted_init_gpt_part_table(dev: &BlkDev) -> Result<(), ExecCommandError> {
+    let dev_full_name = dev.full_name();
+    let args = vec!["--script", &dev_full_name, "mklabel", "gpt"];
+    exec_command("parted", &args)
+}
+
+const LINUX_ROOT_X86_64_TYPE: &str = "4F68BCE3-E8CD-4DB1-96E7-FBCAF984B709";
+
+/// creating partition from PartInfo specification
+/// It assumes that we add partitions sequentially to empty space (for part attributes settings)
+/// Otherwise can produce bonkers layout
+pub fn parted_mkpart(dev: &BlkDev, part: &PartInfo) -> Result<(), ExecCommandError> {
+    // important to shift here by 1 because disk index is starting from 0, and part end pointing to last byte of the partition.
+    let part_end = part.part_end();
+
+    // gpt label should be in double qutes
+    let gpt_label = if let Some(s) = &part.gpt_label {
+        format!("\"{}\"", s)
+    } else {
+        "\"\"".to_string()
+    };
+    log::debug!(
+        "Creatin partition dev:{}, label:{}, fs_type:{}, start:{}, end:{}",
+        dev.full_name(),
+        gpt_label,
+        part.fs_type.to_parted_str(),
+        part.start.to_parted_bytes_str(),
+        part_end.to_parted_bytes_str()
+    );
+    // creating partition
+    exec_parted(&vec![
+        "--script",
+        dev.full_name().as_str(),
+        "mkpart",
+        gpt_label.as_str(),
+        part.fs_type.to_parted_str(),
+        part.start.to_parted_bytes_str().as_str(),
+        part_end.to_parted_bytes_str().as_str(),
+    ])?;
+
+    // set partition options depending on its role
+    if let Some(role) = &part.role {
+        // getting part number of last created partition (hopefully)
+        let part_id = parted_get_last_part_num(dev)?;
+        match role {
+            PartRole::EFI => {
+                exec_parted(&vec![
+                    "--script",
+                    dev.full_name().as_str(),
+                    "set",
+                    &part_id.to_string(),
+                    "esp",
+                    "on",
+                ])?;
+            }
+            // parted --script $install_device type 3 4F68BCE3-E8CD-4DB1-96E7-FBCAF984B709
+            PartRole::ROOT => {
+                exec_parted(&vec![
+                    "--script",
+                    dev.full_name().as_str(),
+                    "type",
+                    &part_id.to_string(),
+                    LINUX_ROOT_X86_64_TYPE,
+                ])?;
+            }
+            _ => (),
+        }
+    };
+
+    Ok(())
+}
+
+/// creating single drive bcachefs volume
+/// compression: lz4, zstd
+pub fn bcachefs_format(
+    dev_name: &str,
+    compression: Option<String>,
+    password: Option<String>,
+) -> Result<(), ExecCommandError> {
+    // sudo bcachefs format --compression=lz4 --background_compression=lz4 --encrypted /dev/loop0
+    // --data_checksum=none - do not make sense on single dev volumes
+    // sudo bcachefs format --force --compression=lz4 --background_compression=lz4 --encrypted  --passphrase_file=./test.pass /dev/loop0
+
+    let mut arg = vec!["format", "--force"];
+    // if compression algorythm specified
+    let maybe_comp_cmd = compression.and_then(|alg| Some(format!("--compression={}", alg)));
+    if let Some(comp_cmd) = &maybe_comp_cmd {
+        arg.push(comp_cmd);
+    }
+    // if we want encrypted volume
+    if let Some(passw) = password {
+        // creating tmp file with password
+        fs::write("/tmp/bzzpsspass.txt", &passw)?;
+        arg.push("--encrypted");
+        arg.push("--passphrase_file=/tmp/bzzpsspass.txt");
+    }
+
+    // add dev name at the end
+    arg.push(dev_name);
+
+    let out = exec_command("bcachefs", &arg);
+
+    // ignore any errors while deleting pass tmp file
+    let _ = fs::remove_file("/tmp/bzzpsspass.txt");
+
+    out
+}
+
+/// unlok encrypted bcache volume
+pub fn bcachefs_unlock(dev_name: &str, pass: &str) -> Result<(), ExecCommandError> {
+    // bcachefs unlock --file=/tmp/bzzpsspass.txt /dev/loop0
+    let arg = vec!["unlock", "--file=/tmp/bzzpsspass.txt ", dev_name];
+    // creating tmp file with password
+    fs::write("/tmp/bzzpsspass.txt", &pass)?;
+
+    let out = exec_command("bcachefs", &arg);
+    // ignore any errors while deleting pass tmp file
+    let _ = fs::remove_file("/tmp/bzzpsspass.txt");
+
+    out
+}
+
+/// create subvolume
+pub fn bcachefs_create_subvolume(vol_path: &str) -> Result<(), ExecCommandError> {
+    // sudo bcachefs subvolume create /mnt/test/nyan
+    exec_command("bcachefs", &vec!["subvolume", "create", vol_path])
+}
+
+/// mount bcachefs
+pub fn bcachefs_mount(dev_name: &str, mount_point: &str) -> Result<(), ExecCommandError> {
+    // sudo mount -t bcachefs /dev/loop0 /mnt/test
+    exec_command("mount", &vec!["-t", "bcachefs", dev_name, mount_point])
+}
+
+pub fn mount_fs(dev_name: &str, mount_point: &str) -> Result<(), ExecCommandError> {
+    // sudo mount -t bcachefs /dev/loop0 /mnt/test
+    exec_command("mount", &vec![dev_name, mount_point])
+}
+
+pub fn swapon(dev_name: &str) -> Result<(), ExecCommandError> {
+    exec_command("swapon", &vec![dev_name])
+}
+
+
+pub fn fatlabel(dev: &str, label: &str) -> Result<(), ExecCommandError> {
+    //fatlabel /dev/sda1 ESP
+    exec_command("fatlabel", &vec![dev, label])
+}
+
+pub fn mkfs_fat32(dev: &str, maybe_label: Option<&str>) -> Result<(), ExecCommandError> {
+    //mkfs.fat -F 32 /dev/sda1
+    exec_command("mkfs.fat", &vec!["-F", "32", dev])?;
+
+    // if need to set label
+    if let Some(label) = maybe_label {
+        fatlabel(dev, label)
+    } else {
+        Ok(())
+    }
+}
+
+/// mkfs.fat -F 32 /dev/sda1
+/// fatlabel /dev/sda1 ESP
+pub fn mkfs_esp(dev: &str) -> Result<(), ExecCommandError> {
+    mkfs_fat32(dev, Some("ESP"))
+}
+
+pub fn mkswap(dev: &str) -> Result<(), ExecCommandError> {
+    //mkswap -L SWAP /dev/sda4
+    exec_command("mkswap", &vec!["-L", "bee-swap", dev])
+}

src/kira_theming.rs

@@ -20,6 +20,7 @@
 */
 
 use iced::{Color, Theme, color};
+use iced::widget::container;
 
 // Function returns theme to be used by installer
 pub fn main_theme() -> Theme {
@@ -38,6 +39,20 @@ pub fn change_lightnes(c: &Color, factor: f32) -> Color {
     res
 }
 
+
+pub fn dialog_background(_theme: &Theme) -> container::Style {
+    let mut back = _theme.palette().background.clone();
+    back.a  = 0.8;
+    container::Style {
+        background: Some(iced::Background::Color(back)),
+        ..container::Style::default()
+    }
+}
+
+pub fn warning_dialog(_theme: &Theme) -> container::Style {
+    container::bordered_box(_theme).background(color!(0xDB5375))
+}
+
 // pub fn text_with_border(_theme: &Theme) -> container::Style {
 
 //     container::Style {

src/locales/en.json

@@ -4,7 +4,10 @@
   "button.next": "Next",
   "button.back": "Back",
   "button.cancel": "Cancel",
+  "button.finish": "Finish",
   "button.exit": "Exit",
+  "button.yes": "Yes",
+  "button.no": "No",
   "wellcome.text": "Welcome to Kira Installer!",
   "wellcome.choose_language": "Please select language to use during istalation!",
   "license.license": "This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.\n\nThis program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.\n\nYou should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.",
@@ -37,6 +40,7 @@
   "partition.select_swapmode": "Select swap partition mode",
   "partition.use_zram": "Use zram technology",
   "partition.use_secure_boot": "Setup secure boot",
+  "partition.encrypt_drive": "Encrypt drive",
   "partition.current_dev_layout": "Current device layout",
   "partition.current_after_install": "After installation device will look like this",
   "security.user_name": "User login name",
@@ -46,5 +50,7 @@
   "security.root_password": "Root password",
   "security.pass_low": "low security",
   "security.pass_middle": "normal security",
-  "security.pass_hight": "hight security"
+  "security.pass_hight": "hight security",
+  "install.caption": "Now we will beee install Bzz Linux to your PC",
+  "install.warning": "We a ready to start installation, this action will destroy all data on select drive!\n\nDo you want to proceed?"
 }

src/main.rs

@@ -35,6 +35,7 @@ use crate::stages::welcome::WelcomeStage;
 rust_i18n::i18n!("src/locales", fallback = "en");
 mod kira_color_bar;
 mod kira_disk_layout;
+mod kira_system;
 mod kira_logger;
 mod kira_scroll_list;
 mod kira_size;
@@ -53,6 +54,7 @@ enum Views {
     Keyboard(stages::keyboard::KeyboardStage),
     Partition(stages::partition::PartitionStage),
     Security(stages::security::SecurityStage),
+    Install(stages::install::InstallStage),
 }
 
 enum Message {
@@ -65,39 +67,36 @@ enum Message {
     Keyboard(stages::keyboard::Message),
     Partition(stages::partition::Message),
     Security(stages::security::Message),
+    Install(stages::install::Message),
 }
 
 struct KiraState {
     current_view: Views,
-    toml_config: toml::Table,
-    config: KiraConfig,
+    k_config: KiraConfig,
     stages_save: Vec<Views>,
 }
 
-const CONFIG_PATH_STR: &str = "kira_config.toml";
+// const CONFIG_PATH_STR: &str = "kira_config.toml";
 
-fn load_kira_config(config_path: &str) -> Result<toml::Table, Box<dyn std::error::Error>> {
-    use std::fs;
-    use toml::Table;
-    // 1. Read the file content into a String
-    let content = fs::read_to_string(config_path)?;
+// fn load_kira_config(config_path: &str) -> Result<toml::Table, Box<dyn std::error::Error>> {
+//     use std::fs;
+//     use toml::Table;
+//     // 1. Read the file content into a String
+//     let content = fs::read_to_string(config_path)?;
 
-    // 2. Parse the string into a Table
-    let table: Table = content.parse()?;
+//     // 2. Parse the string into a Table
+//     let table: Table = content.parse()?;
 
-    log::info!("{:?}", table);
-    Ok(table)
-}
+//     log::info!("{:?}", table);
+//     Ok(table)
+// }
 
 impl KiraState {
     fn boot() -> (Self, Task<Message>) {
         (
             Self {
                 current_view: Views::Start,
-                toml_config: toml::Table::new(),
-                config: KiraConfig {
-                    config_trail: Vec::new(),
-                },
+                k_config: KiraConfig ::default(),
                 stages_save: Vec::new(),
             },
             Task::done(Message::Start),
@@ -115,30 +114,27 @@ fn view(k_state: &KiraState) -> Element<'_, Message> {
         Views::Locale(locale_stage) => locale_stage.view().map(Message::Locale),
         Views::Keyboard(keyboard_stage) => keyboard_stage.view().map(Message::Keyboard),
         Views::Partition(partition_stage) => partition_stage.view().map(Message::Partition),
-        Views::Security(security_stage) => security_stage.view().map(Message::Security)
+        Views::Security(security_stage) => security_stage.view().map(Message::Security),
+        Views::Install(install_stage) => install_stage.view().map(Message::Install),
     }
 }
 
 fn update(k_state: &mut KiraState, message: Message) -> Task<Message> {
     match message {
-        Message::Start => match load_kira_config(CONFIG_PATH_STR) {
-            Ok(conf) => {
-                log::info!("Config loaded!");
-                k_state.toml_config = conf;
-                k_state.current_view = Views::Welcome(WelcomeStage::new());
+        Message::Start => {
+                log::info!("Starting!");
+                k_state.current_view = Views::Welcome(WelcomeStage::new(k_state.k_config.clone()));
                 Task::none()
-            }
-            Err(ex) => {
-                log::error!("Error reading config {}: {}", CONFIG_PATH_STR, ex);
-                iced::exit()
-            }
         },
         Message::Welcome(wlc_msg) => {
             if let Views::Welcome(wlc_view) = &mut k_state.current_view {
                 match wlc_view.update(wlc_msg) {
                     StageAction::Next(welcome_res) => {
-                        k_state.config.config_trail.push(welcome_res);
-                        let s_state = std::mem::replace(&mut k_state.current_view, Views::License(license::LicenseStage {}));
+                        k_state.k_config = welcome_res;
+                        let s_state = std::mem::replace(
+                            &mut k_state.current_view,
+                            Views::License(license::LicenseStage::new(k_state.k_config.clone())),
+                        );
                         k_state.stages_save.push(s_state);
                         Task::none()
                     }
@@ -154,15 +150,17 @@ fn update(k_state: &mut KiraState, message: Message) -> Task<Message> {
                 let action = license_view.update(license_message);
                 match action {
                     StageAction::Next(license_res) => {
-                        k_state.config.config_trail.push(license_res);
-                        let s_state = std::mem::replace(&mut k_state.current_view, Views::Network(network::NetworkStage::new(&k_state.toml_config)));
+                        k_state.k_config = license_res;
+                        let s_state = std::mem::replace(
+                            &mut k_state.current_view,
+                            Views::Network(network::NetworkStage::new(k_state.k_config.clone())),
+                        );
                         k_state.stages_save.push(s_state);
                         Task::done(Message::Network(network::Message::CheckNetwork))
                     }
                     StageAction::Abort => iced::exit(),
                     StageAction::Back => {
                         k_state.current_view = k_state.stages_save.pop().unwrap();
-                        k_state.config.config_trail.pop();
                         Task::none()
                     }
                     StageAction::None => Task::none(),
@@ -178,14 +176,16 @@ fn update(k_state: &mut KiraState, message: Message) -> Task<Message> {
                     network::UpdateResult::Task(t) => t.map(Message::Network),
                     network::UpdateResult::StageAction(action) => match action {
                         StageAction::Next(network_res) => {
-                            k_state.config.config_trail.push(network_res);
-                            let s_state = std::mem::replace(&mut k_state.current_view,Views::TimeZone(stages::timezone::TimeZoneStage::new()));
+                            k_state.k_config = network_res;
+                            let s_state = std::mem::replace(
+                                &mut k_state.current_view,
+                                Views::TimeZone(stages::timezone::TimeZoneStage::new(k_state.k_config.clone())),
+                            );
                             k_state.stages_save.push(s_state);
                             Task::none()
                         }
                         StageAction::Back => {
                             k_state.current_view = k_state.stages_save.pop().unwrap();
-                            k_state.config.config_trail.pop();
                             Task::none()
                         }
                         _ => Task::none(),
@@ -200,14 +200,16 @@ fn update(k_state: &mut KiraState, message: Message) -> Task<Message> {
                 let action = timezone_view.update(timezone_message);
                 match action {
                     StageAction::Next(tz_res) => {
-                        k_state.config.config_trail.push(tz_res);
-                        let s_state = std::mem::replace(&mut k_state.current_view,Views::Locale(stages::locale::LocaleStage::new(&k_state.config)));
+                        k_state.k_config = tz_res;
+                        let s_state = std::mem::replace(
+                            &mut k_state.current_view,
+                            Views::Locale(stages::locale::LocaleStage::new(k_state.k_config.clone())),
+                        );
                         k_state.stages_save.push(s_state);
                         Task::none()
                     }
                     StageAction::Abort => iced::exit(),
                     StageAction::Back => {
-                        k_state.config.config_trail.pop();
                         k_state.current_view = k_state.stages_save.pop().unwrap();
                         Task::none()
                     }
@@ -221,13 +223,15 @@ fn update(k_state: &mut KiraState, message: Message) -> Task<Message> {
             if let Views::Locale(locale_view) = &mut k_state.current_view {
                 match locale_view.update(locale_msg) {
                     StageAction::Next(locale_res) => {
-                        k_state.config.config_trail.push(locale_res);
-                        let s_state = std::mem::replace(&mut k_state.current_view,Views::Keyboard(stages::keyboard::KeyboardStage::new()));
+                        k_state.k_config = locale_res;
+                        let s_state = std::mem::replace(
+                            &mut k_state.current_view,
+                            Views::Keyboard(stages::keyboard::KeyboardStage::new(k_state.k_config.clone())),
+                        );
                         k_state.stages_save.push(s_state);
                         Task::none()
                     }
                     StageAction::Back => {
-                        k_state.config.config_trail.pop();
                         k_state.current_view = k_state.stages_save.pop().unwrap();
                         Task::none()
                     }
@@ -241,10 +245,13 @@ fn update(k_state: &mut KiraState, message: Message) -> Task<Message> {
             if let Views::Keyboard(keyboard_view) = &mut k_state.current_view {
                 match keyboard_view.update(keyboard_msg) {
                     StageAction::Next(keyboard_res) => {
-                        match stages::partition::PartitionStage::new(&k_state.toml_config) {
+                        k_state.k_config = keyboard_res;
+                        match stages::partition::PartitionStage::new(k_state.k_config.clone()) {
                             Ok(part_stage) => {
-                                k_state.config.config_trail.push(keyboard_res);
-                                let s_state = std::mem::replace(&mut k_state.current_view,Views::Partition(part_stage));
+                                let s_state = std::mem::replace(
+                                    &mut k_state.current_view,
+                                    Views::Partition(part_stage),
+                                );
                                 k_state.stages_save.push(s_state);
                             }
                             Err(ex) => {
@@ -254,7 +261,6 @@ fn update(k_state: &mut KiraState, message: Message) -> Task<Message> {
                         Task::none()
                     }
                     StageAction::Back => {
-                        k_state.config.config_trail.pop();
                         k_state.current_view = k_state.stages_save.pop().unwrap();
                         Task::none()
                     }
@@ -263,18 +269,20 @@ fn update(k_state: &mut KiraState, message: Message) -> Task<Message> {
             } else {
                 Task::none()
             }
-        },
+        }
         Message::Partition(partition_msg) => {
             if let Views::Partition(partition_view) = &mut k_state.current_view {
                 match partition_view.update(partition_msg) {
                     StageAction::Next(partition_res) => {
-                        k_state.config.config_trail.push(partition_res);
-                        let s_state = std::mem::replace(&mut k_state.current_view,Views::Security(stages::security::SecurityStage::new()));
+                        k_state.k_config = partition_res;
+                        let s_state = std::mem::replace(
+                            &mut k_state.current_view,
+                            Views::Security(stages::security::SecurityStage::new(k_state.k_config.clone())),
+                        );
                         k_state.stages_save.push(s_state);
                         Task::none()
                     }
                     StageAction::Back => {
-                        k_state.config.config_trail.pop();
                         k_state.current_view = k_state.stages_save.pop().unwrap();
                         Task::none()
                     }
@@ -283,17 +291,20 @@ fn update(k_state: &mut KiraState, message: Message) -> Task<Message> {
             } else {
                 Task::none()
             }
-        },
+        }
         Message::Security(security_msg) => {
             if let Views::Security(security_view) = &mut k_state.current_view {
                 match security_view.update(security_msg) {
                     StageAction::Next(security_res) => {
-                        k_state.config.config_trail.push(security_res);
-                        //let s_state = std::mem::replace(&mut k_state.current_view,
+                        k_state.k_config = security_res;
+                        let s_state = std::mem::replace(
+                            &mut k_state.current_view,
+                            Views::Install(stages::install::InstallStage::new(k_state.k_config.clone())),
+                        );
+                        k_state.stages_save.push(s_state);
                         Task::none()
                     }
                     StageAction::Back => {
-                        k_state.config.config_trail.pop();
                         k_state.current_view = k_state.stages_save.pop().unwrap();
                         Task::none()
                     }
@@ -302,8 +313,24 @@ fn update(k_state: &mut KiraState, message: Message) -> Task<Message> {
             } else {
                 Task::none()
             }
-        },
-
+        }
+        Message::Install(install_msg) => {
+            if let Views::Install(install_view) = &mut k_state.current_view {
+                let update_result = install_view.update(install_msg);
+                match update_result {
+                    stages::install::Update::Task(t) => t.map(Message::Install),
+                    stages::install::Update::StgAct(stage_action) => match stage_action {
+                        StageAction::Back => {
+                            k_state.current_view = k_state.stages_save.pop().unwrap();
+                            Task::none()
+                        }
+                        _ => Task::none(),
+                    },
+                }
+            } else {
+                Task::none()
+            }
+        }
     }
 }
 

src/stage.rs

@@ -18,118 +18,43 @@
    This file contains basic enums and structs to be used with stages.
 */
 
-use std::collections::HashMap;
+use crate::stages;
+
 
 #[derive(Debug, Clone)]
-pub enum ConfigValue {
-    String(String),
-    I64(i64),
-    U64(u64),
-    F64(f64),
-    Bool(bool),
-    Vector(Vec<ConfigValue>),
-    Dictionary(HashMap<String, ConfigValue>),
-}
-
-#[derive(Debug, Clone)]
-pub struct StageResult {
-    pub name: String,
-    pub config: Option<HashMap<String, ConfigValue>>,
-    pub error: Option<String>,
-}
-
-impl StageResult {
-    pub fn new(name: &str) -> Self {
-        Self {
-            name: name.into(),
-            config: None,
-            error: None,
-        }
-    }
-
-    pub fn add_error(mut self, ex: String) -> Self {
-        self.error = Some(ex);
-        self
-    }
-
-    pub fn add_val(mut self, val_name: &str, conf_val: ConfigValue) -> Self {
-        match &mut self.config {
-            Some(c) => {
-                c.insert(val_name.into(), conf_val);
-            }
-            None => {
-                self.config = Some(HashMap::from([(val_name.into(), conf_val)]));
-            }
-        }
-        self
-    }
-
-    pub fn add_val_string(self, val_name: &str, v: String) -> Self {
-        self.add_val(val_name, ConfigValue::String(v))
-    }
-
-    pub fn add_val_bool(self, val_name: &str, v: bool) -> Self {
-        self.add_val(val_name, ConfigValue::Bool(v))
-    }
-
-    pub fn add_val_u64(self, val_name: &str, v: u64) -> Self {
-        self.add_val(val_name, ConfigValue::U64(v))
-    }
-
-    pub fn get_val(&self, val_name: &str) -> Option<ConfigValue> {
-        let v = self
-            .config
-            .as_ref()
-            .and_then(|hm| hm.get(val_name).cloned());
-        return v;
-    }
-
-    pub fn get_val_str(&self, val_name: &str) -> Option<String> {
-        match self.get_val(val_name) {
-            Some(ConfigValue::String(v)) => Some(v),
-            _ => None,
-        }
-    }
-
-    pub fn get_val_bool(&self, val_name: &str) -> Option<bool> {
-        match self.get_val(val_name) {
-            Some(ConfigValue::Bool(v)) => Some(v),
-            _ => None,
-        }
-    }
-}
-
 pub struct KiraConfig {
-    pub config_trail: Vec<StageResult>,
+    pub res_welcome: Option<stages::welcome::WelcomeStageResult>,
+    pub res_license: bool,
+    pub res_network: Option<stages::network::NetworkStageResult>,
+    pub res_timezone: Option<stages::timezone::TimeZoneStageResult>,
+    pub res_locale: Option<stages::locale::LocaleStageResult>,
+    pub res_keyboard: Option<stages::keyboard::KeyboardStageResult>,
+    pub res_partition: Option<stages::partition::PartitionStageResult>,
+    pub res_security: Option<stages::security::SecurityStageResult>,
+    pub res_install: Option<stages::install::InstallStageResult>,
 }
 
 impl Default for KiraConfig {
     fn default() -> Self {
         Self {
-            config_trail: Vec::new(),
+            res_welcome: None,
+            res_license: false,
+            res_network: None,
+            res_timezone: None,
+            res_locale: None,
+            res_keyboard: None,
+            res_partition: None,
+            res_security: None,
+            res_install: None,
         }
     }
 }
 
-impl KiraConfig {
-    pub fn get_stage(&self, name: &str) -> Option<StageResult> {
-        self.config_trail
-            .iter()
-            .find(|v| v.name == name)
-            .and_then(|v| Some(v.clone()))
-    }
-    pub fn pop_last(&mut self) -> Option<StageResult> {
-        self.config_trail.pop()
-    }
-    pub fn push(&mut self, stage_result: StageResult) {
-        self.config_trail.push(stage_result);
-    }
-}
 
 #[derive(Debug, Clone)]
 pub enum StageAction {
     Back,
     None,
-    Next(StageResult),
+    Next(KiraConfig),
     Abort,
 }

src/stages/install/mod.rs

@@ -0,0 +1,370 @@
+// <Kira Installer - universal Linux installer.>
+// Copyright (C) <2026>  <Kira Foundation>
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+/*
+   Actual installation script.
+*/
+
+use std::path::Path;
+
+use crate::{
+    kira_disk_layout::{self, BlkDev, FSType, PartLayout, PartRole},
+    kira_size::KiraSize,
+    kira_system::{self, ExecCommandError},
+    kira_theming,
+    stage::{KiraConfig, StageAction},
+    stages::partition::PartitionStageResult,
+};
+use iced::{
+    Alignment, Task,
+    futures::{self, SinkExt, StreamExt, TryStreamExt, channel::mpsc::SendError},
+    widget,
+};
+use iced::{Color, Length, futures::channel::mpsc::Sender, widget::container};
+
+use log;
+use rust_i18n::t;
+
+const EFI_BOOT_MOUNT_POINT: &str = "/beefi";
+const MNT_DIR: &str = "/mnt/inst_root";
+const ROOT_PARTLABEL_DEV: &str = "/dev/disk/by-partlabel/bee-root";
+
+/// Creates new GPT table and partitions from PartLayout
+pub fn create_partitions(part_layout: &PartLayout) -> Result<(), ExecCommandError> {
+    log::info!("Creating GPT part table...");
+    kira_system::parted_init_gpt_part_table(&part_layout.dev)?;
+    log::info!("Start to create partitions...");
+    for part in &part_layout.part_list {
+        log::info!("Creating partition: {}", part);
+        kira_system::parted_mkpart(&part_layout.dev, part)?;
+    }
+    Ok(())
+}
+
+/// inits bcachefs volume for installation to use
+/// Formats device to bcachefs
+/// Unlock it if encryption used
+/// Mount to specified dir
+/// creates subvolumes bzz/root bzz/home
+pub fn bcachefs_init(
+    dev_name: &str,
+    mnt_dir: &str,
+    password: Option<String>,
+) -> Result<(), ExecCommandError> {
+    // if encryption used - unlock drive
+    if let Some(pass) = password {
+        kira_system::bcachefs_unlock(dev_name, pass.as_str())?;
+    }
+
+    //mount drive
+    kira_system::bcachefs_mount(dev_name, mnt_dir)?;
+
+    // Creating bzz-snaps directory for root snapshoots
+    std::fs::create_dir(format!("{}{}", mnt_dir, "/bzz-snaps"))?;
+
+    // Creating boot directory for efi mounting
+    std::fs::create_dir_all(format!("{}{}", mnt_dir, EFI_BOOT_MOUNT_POINT))?;
+
+    // create subvolumes
+    for vol_name in ["/home", "/usr", "/var", "/var/tmp"] {
+        let vol_path = format!("{}{}", mnt_dir, vol_name);
+        kira_system::bcachefs_create_subvolume(vol_path.as_str())?;
+    }
+
+    Ok(())
+}
+
+pub fn init_disk(part_layout: &PartLayout, mnt_dir: &str) -> Result<(), ExecCommandError> {
+
+
+    let mnt_path = Path::new(mnt_dir);
+    log::info!("Cheking is MNT path exists: {}", mnt_dir);
+    if !mnt_path.exists() {
+        log::info!("MNT path do not exist, creating it...");
+        std::fs::create_dir_all(mnt_path)?;
+    }
+
+    // use parted to create partition gpt layout
+    create_partitions(part_layout)?;
+
+    // format partitions
+    for part in &part_layout.part_list {
+        match part.role {
+            Some(PartRole::EFI) => {
+                if let Some(part_l) = part.partlabel_dev() {
+                    kira_system::mkfs_esp(&part_l)?;
+                }
+            }
+            Some(PartRole::ROOT) => {
+                if let Some(part_l) = part.partlabel_dev() {
+                    if let FSType::BCACHEFS(bc_par) = &part.fs_type {
+                        log::info!("Formating root pertition.");
+                        kira_system::bcachefs_format(&part_l, bc_par.password.clone(), bc_par.password.clone())?;
+                        // init root
+                        log::info!("Mount and init root partition.");
+                        bcachefs_init(ROOT_PARTLABEL_DEV, mnt_dir, bc_par.password.clone())?;
+                    } else {
+                        return Err(ExecCommandError::Other(
+                            "ROOT partition is not BCACHEFS type!".into(),
+                        ));
+                    }
+                }
+            }
+            Some(PartRole::SWAP) => {
+                if let Some(part_l) = part.partlabel_dev() {
+                    kira_system::mkswap(&part_l)?;
+                }
+            }
+            _ => (),
+        }
+    }
+
+    Ok(())
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum InstallationState {
+    UserConfirmDialog,
+    Installing,
+    Finish,
+    Error,
+}
+
+#[derive(Debug, Clone)]
+pub struct InstallStageResult {
+    pub sucess: Result<(), String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct InstallStage {
+    state: InstallationState,
+    progress: f32,
+    progress_message: String,
+    modal_backgroud: Color,
+    k_config: KiraConfig,
+}
+
+#[derive(Debug, Clone)]
+pub enum Message {
+    UserConfirms,
+    UserDenies,
+    Sucess,
+    Cancel,
+    Finish,
+    UpdateProgress(Result<(f32, String), String>),
+    Failure(String),
+}
+
+#[derive(Debug)]
+pub enum Update {
+    StgAct(StageAction),
+    Task(Task<Message>),
+}
+
+async fn init_disk_async(part_layout: PartLayout, mnt_dir: String) -> Result<(), ExecCommandError> {
+    use blocking;
+    blocking::unblock(move || init_disk(&part_layout, &mnt_dir)).await
+}
+
+fn do_install(
+    k_config: KiraConfig,
+) -> impl futures::Stream<Item = Result<(f32, String), ExecCommandError>> {
+    iced::stream::channel(
+        100,
+        |mut output: Sender<Result<(f32, String), ExecCommandError>>| async move {
+            //sleep(Duration::from_millis(10)).await;
+            let disk_layout = k_config.res_partition.unwrap().part_layout.clone();
+
+            // creating gpt partition table
+            let res = init_disk_async(disk_layout, MNT_DIR.into()).await;
+            let res_err = res.is_err();
+            output
+                .send(res.map(|_| (1.1f32, "Formatting bcachefs".into())))
+                .await
+                .unwrap();
+
+            if res_err {
+                return;
+            }
+
+            // Check if send fails (receiver dropped/cancelled)
+            // if output.send(res).await.is_err() {
+            //     return; // Exit early if UI is gone
+            // }
+
+            // Optional: Send completion or error state here
+            // output.send(Message::WorkFailed).await.ok();
+        },
+    )
+}
+
+fn check_kconfig(k_config: &KiraConfig)  -> Result<(), String> {
+    if k_config.res_welcome.is_none(){ Err("Missing wellcome stage result!".into())}
+    else if k_config.res_license == false { Err("License is NOT accepted!".into())}
+    else if k_config.res_locale.is_none(){ Err("Missing locale stage result!".into())}
+    else if k_config.res_network.is_none(){ Err("Missing network stage result!".into())}
+    else if k_config.res_keyboard.is_none(){ Err("Missing keyboard stage result!".into())}
+    else if k_config.res_timezone.is_none(){ Err("Missing timezone stage result!".into())}
+    else if k_config.res_partition.is_none(){ Err("Missing partition stage result!".into())}
+    else if k_config.res_security.is_none(){ Err("Missing security stage result!".into())}
+    else {
+        Ok(())
+    }
+}
+
+impl InstallStage {
+    pub fn new(k_config: KiraConfig) -> Self {
+        let mut modal_backgroud = kira_theming::main_theme().palette().background;
+        modal_backgroud.a = 0.5;
+        Self {
+            modal_backgroud: modal_backgroud,
+            state: InstallationState::UserConfirmDialog,
+            progress: 0.0,
+            progress_message: String::new(),
+            k_config: k_config,
+        }
+    }
+
+    fn gen_result(&mut self) -> KiraConfig {
+        self.k_config.res_install = Some(InstallStageResult { sucess: Ok(()) });
+        self.k_config.clone()
+    }
+
+    pub fn update(&mut self, message: Message) -> Update {
+        match message {
+            Message::UserDenies => Update::StgAct(StageAction::Back),
+            Message::UserConfirms => {
+
+                log::info!("Cheking config...");
+                match check_kconfig(&self.k_config) {
+                    Ok(()) => log::info!("Config looks good."),
+                    Err(ex) => {
+                        log::error!("{}", ex);
+                        self.state = InstallationState::Error;
+                        return Update::StgAct(StageAction::None);
+                    }
+                }
+                
+
+                // starting installation process here
+                log::info!("Starting disk partitioning.");
+
+                self.state = InstallationState::Installing;
+                Update::Task(Task::run(
+                    do_install(self.k_config.clone()).map_err(|ex| ex.to_string()),
+                    Message::UpdateProgress,
+                ))
+                //Update::Task(Task::perform(, Message::PartitioningFinish))
+            }
+            Message::UpdateProgress(maybe_msg) => {
+                match maybe_msg {
+                    Ok((progress, msg)) => {
+                        self.progress = progress;
+                        self.progress_message = msg;
+                        Update::StgAct(StageAction::None)
+                    }
+                    Err(ex) => {
+                        log::error!("{}", &ex);
+                        self.state = InstallationState::Error;
+                        Update::StgAct(StageAction::None)
+                    }
+                }
+                //Update::StgAct(StageAction::None)
+            }
+            Message::Failure(ex) => {
+                self.state = InstallationState::Error;
+                Update::StgAct(StageAction::Abort)
+            }
+            Message::Cancel => Update::StgAct(StageAction::Abort),
+            Message::Sucess => Update::StgAct(StageAction::None),
+            Message::Finish => Update::StgAct(StageAction::None),
+        }
+    }
+
+    pub fn view(&self) -> iced::Element<'_, Message> {
+        let action_button = if self.state == InstallationState::Finish {
+            widget::button(widget::text(t!("button.finish"))).on_press(Message::Finish)
+        } else {
+            widget::button(widget::text(t!("button.cancel"))).on_press(Message::Cancel)
+        };
+
+        // Embed the image bytes into the executable
+        let logo_handle = widget::image::Handle::from_bytes(kira_theming::get_logo_bytes());
+
+        let main_content = widget::column![
+            widget::container(
+                widget::column![
+                    widget::image(logo_handle)
+                        .width(iced::Pixels(128.0))
+                        .height(iced::Pixels(128.0)),
+                    widget::text(t!("install.caption")),
+                    widget::progress_bar(0.0..=100.0, self.progress),
+                    widget::text(self.progress_message.clone()),
+                ]
+                .padding(10)
+                .spacing(10)
+                .align_x(Alignment::Center)
+            )
+            .height(iced::Length::Fill)
+            .width(iced::Length::Fill)
+            .align_x(Alignment::Center)
+            .align_y(Alignment::Center),
+            widget::container(action_button)
+                .width(iced::Length::Fill)
+                .align_y(Alignment::End)
+                .padding(10),
+        ]
+        .align_x(Alignment::Center)
+        .spacing(10);
+
+        let page_stack = widget::Stack::with_capacity(2).push(main_content);
+
+        if self.state == InstallationState::UserConfirmDialog {
+            page_stack
+                .push(widget::opaque(
+                    container(
+                        container(
+                            widget::column![
+                                widget::text(t!("install.warning")).align_x(Alignment::Center),
+                                widget::row![
+                                    widget::button(widget::text(t!("button.no")))
+                                        .on_press(Message::UserDenies),
+                                    widget::space::horizontal(), // Pushes the right button to the far right
+                                    widget::button(widget::text(t!("button.yes")))
+                                        .on_press(Message::UserConfirms)
+                                ]
+                                .padding(10)
+                            ]
+                            .spacing(10)
+                            .padding(10)
+                            .width(512)
+                            .align_x(Alignment::Center),
+                        )
+                        .style(kira_theming::warning_dialog),
+                    )
+                    .style(container::bordered_box)
+                    .style(kira_theming::dialog_background)
+                    .align_x(Alignment::Center)
+                    .align_y(Alignment::Center)
+                    .height(Length::Fill)
+                    .width(Length::Fill),
+                ))
+                .into()
+        } else {
+            page_stack.into()
+        }
+    }
+}

src/stages/keyboard/mod.rs

@@ -18,10 +18,10 @@
    This is Keyboar stage, used to select Keyboard Layouts
 */
 
-use log;
 use crate::kira_scroll_list::{self, ListViewMessage};
-use crate::stage::{StageAction, StageResult};
+use crate::stage::{KiraConfig, StageAction};
 use iced::{Alignment, Length, widget};
+use log;
 use rust_i18n::t;
 use std::collections::HashMap;
 
@@ -119,9 +119,15 @@ pub struct KeyboardStage {
     variants_map: HashMap<String, Vec<Variant>>,
     variants: Vec<Variant>,
     variant: Option<usize>,
-
     keyboard_layout: Option<KeyboarLayout>,
     // selected_kbd_layout_id: Option<usize>,
+    k_config: KiraConfig,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct KeyboardStageResult {
+    pub keyboard_model: KeyboarModel,
+    pub keyboard_layout: KeyboarLayout,
 }
 
 #[derive(Debug, Clone)]
@@ -224,7 +230,7 @@ fn get_layouts_blocking() -> std::io::Result<(
 }
 
 impl KeyboardStage {
-    pub fn new() -> Self {
+    pub fn new(k_config: KiraConfig) -> Self {
         match get_layouts_blocking() {
             Ok((models, layouts, variants_map)) => {
                 let def_layout = layouts
@@ -252,6 +258,7 @@ impl KeyboardStage {
                     layout: def_layout,
                     variant: Some(0),
                     keyboard_layout: keyboard_layout,
+                    k_config: k_config,
                 }
             }
             Err(ex) => {
@@ -268,22 +275,21 @@ impl KeyboardStage {
                     layout: None,
                     variant: None,
                     keyboard_layout: None,
+                    k_config: k_config,
                 }
             }
         }
     }
 
-    fn gen_result(&self) -> StageResult {
-        if let Some(model) = &self.model
-            && let Some(k_l) = &self.keyboard_layout
-        {
-            StageResult::new("keyboard")
-            .add_val_string("model", model.model.clone())
-            .add_val_string("layout", k_l.to_result())
-        } else {
-            StageResult::new("keyboard")
-            .add_error("Something go terrible wrong, there is no keyboard layouts.".into())
-        }
+    fn gen_result(&mut self) -> KiraConfig {
+        self.k_config.res_keyboard = Some(KeyboardStageResult {
+            keyboard_model: self.model.clone().expect("Keyboard model must be choosed!"),
+            keyboard_layout: self
+                .keyboard_layout
+                .clone()
+                .expect("Keyboard layout must be choosed!"),
+        });
+        self.k_config.clone()
     }
 
     pub fn update(&mut self, message: Message) -> StageAction {

src/stages/license/mod.rs

@@ -23,10 +23,12 @@ use iced::{Alignment, widget};
 use rust_i18n::t;
 
 use crate::stage;
-use crate::stage::StageResult;
+use crate::stage::KiraConfig;
 
 #[derive(Debug, Clone)]
-pub struct LicenseStage {}
+pub struct LicenseStage {
+    k_config: KiraConfig,
+}
 
 #[derive(Debug, Clone)]
 pub enum Message {
@@ -42,14 +44,18 @@ pub enum Message {
 //const LICENSE_TEXT: &str = include_str!("gpl-3.0.txt");
 
 impl LicenseStage {
-    fn accepted() -> StageResult {
-        StageResult::new("license")
-        .add_val_bool("accepted", true)
+    pub fn new(k_config: KiraConfig) -> Self {
+        Self { k_config: k_config }
+    }
+
+    fn accepted(&mut self) -> KiraConfig {
+        self.k_config.res_license = true;
+        self.k_config.clone()
     }
 
     pub fn update(&mut self, message: Message) -> stage::StageAction {
         match message {
-            Message::Accept => stage::StageAction::Next(Self::accepted()),
+            Message::Accept => stage::StageAction::Next(self.accepted()),
             Message::Back => stage::StageAction::Back,
             Message::Decline => stage::StageAction::Abort,
         }

src/stages/locale/mod.rs

@@ -20,7 +20,7 @@
 
 use crate::{
     kira_theming,
-    stage::{ConfigValue, KiraConfig, StageAction, StageResult},
+    stage::{KiraConfig, StageAction},
 };
 use iced::{Alignment, widget};
 use rust_i18n::t;
@@ -136,6 +136,13 @@ pub struct LocaleStage {
     locales: Vec<LocaleData>,
     lang_locale_text: String,
     all_locale_text: String,
+    k_config: KiraConfig,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct LocaleStageResult {
+    pub lang_locale: LocaleData,
+    pub formats_locale: LocaleData,
 }
 
 #[derive(Debug, Clone)]
@@ -147,11 +154,12 @@ pub enum Message {
 }
 
 impl LocaleStage {
-    pub fn new(kira_config: &KiraConfig) -> Self {
+    pub fn new(k_config: KiraConfig) -> Self {
         // get seelctet language code from welcome stage
-        let maybe_lang = kira_config
-            .get_stage("welcome")
-            .and_then(|v| v.config.and_then(|v| v.get("loc_code").cloned()));
+        let maybe_lang = k_config
+            .res_welcome
+            .as_ref()
+            .and_then(|rw| Some(rw.loc_code.clone()));
 
         let raw_loc_codes = get_locales_codes_list_blocking().unwrap();
         let raw_loc_descr = get_locales_description_blocking().unwrap();
@@ -174,7 +182,9 @@ impl LocaleStage {
             .collect();
 
         // if we get lang code from wellcome stage, try to fing match with system locales
-        let lang_match = if let Some(ConfigValue::String(lang)) = maybe_lang && lang != "en" {
+        let lang_match = if let Some(lang) = maybe_lang
+            && lang != "en"
+        {
             let lang = lang.replace("-", "_").to_lowercase();
             locales
                 .iter()
@@ -201,23 +211,26 @@ impl LocaleStage {
             locales: locales,
             lang_locale_text: lang_locale_text,
             all_locale_text: all_locale_text,
+            k_config: k_config,
         }
     }
 
-    fn gen_result(&self) -> StageResult {
-        if let Some(lang_locale) = &self.lang_locale
+    fn gen_result(&mut self) -> KiraConfig {
+        self.k_config.res_locale = if let Some(lang_locale) = &self.lang_locale
             && let Some(formats_locale) = &self.formats_locale
         {
-            StageResult::new("locale")
-            .add_val_string("lang_locale", lang_locale.code.clone())
-            .add_val_string("formats_locale", formats_locale.code.clone())
-            
+            Some(LocaleStageResult {
+                lang_locale: lang_locale.clone(),
+                formats_locale: formats_locale.clone(),
+            })
         } else {
             let loc = LocaleData::default();
-            StageResult::new("locale")
-            .add_val_string("lang_locale", loc.code.clone())
-            .add_val_string("formats_locale", loc.code)
-        }
+            Some(LocaleStageResult {
+                lang_locale: loc.clone(),
+                formats_locale: loc,
+            })
+        };
+        self.k_config.clone()
     }
 
     pub fn update(&mut self, message: Message) -> StageAction {

src/stages/mod.rs

@@ -23,3 +23,4 @@ pub mod locale;
 pub mod keyboard;
 pub mod partition;
 pub mod security;
+pub mod install;

src/stages/network/mod.rs

@@ -19,17 +19,16 @@
    it needed for installation to process.
 */
 
-use log;
 use iced::{Alignment, Task, widget};
 use iced_moving_picture::widget::apng;
+use log;
 use rust_i18n::t;
-use toml::Table;
 
-use crate::stage;
-use crate::stage::StageResult;
+use crate::stage::{self, KiraConfig};
 
-#[derive(Debug, Clone)]
-#[derive(PartialEq, Eq)]
+const REQIRE_NETWORK: bool = false;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum State {
     Cheking,
     Normal,
@@ -42,15 +41,21 @@ pub enum CheckResult {
     CheckError,
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub struct NetworkStageResult {
+    pub internet_active: bool,
+    pub use_net_settings: bool,
+}
+
 #[derive(Debug, Clone)]
 pub struct NetworkStage {
     internet_active: bool,
     state: State,
     use_net_settings: bool,
-    reqire_network: bool,
     spinner_frames: apng::Frames,
     logo_handle: widget::image::Handle,
     status_message: String,
+    k_config: KiraConfig,
 }
 
 #[derive(Debug, Clone)]
@@ -95,21 +100,7 @@ async fn check_connected() -> CheckResult {
 }
 
 impl NetworkStage {
-    pub fn new(toml_config: &Table) -> Self {
-        let mut reqire_network = false;
-
-        if let Some(reqire_network_conf) = toml_config
-            .get("network")
-            .and_then(|v| v.as_table())
-            .and_then(|v| v.get("reqire_network"))
-            .and_then(|v| v.as_bool())
-        {
-            log::debug!("Config value reqire_network read {}", reqire_network_conf);
-            reqire_network = reqire_network_conf;
-        } else {
-            log::error!("Error parsing network config. Using default values.");
-        }
-
+    pub fn new(k_config: KiraConfig) -> Self {
         let spinner_frames =
             apng::Frames::from_bytes(crate::kira_theming::get_spiner_bytes()).unwrap();
 
@@ -120,16 +111,19 @@ impl NetworkStage {
             internet_active: false,
             state: State::Cheking,
             use_net_settings: true,
-            reqire_network: reqire_network,
             spinner_frames: spinner_frames,
             status_message: t!("network.checking").into(),
+            k_config: k_config,
         }
     }
 
-    fn gen_result(&self) -> StageResult {
-        StageResult::new("network")
-        .add_val_bool("internet_active", self.internet_active)
-        .add_val_bool("use_net_settings", self.use_net_settings)
+    fn gen_result(&self) -> KiraConfig {
+        let mut k_config = self.k_config.clone();
+        k_config.res_network = Some(NetworkStageResult {
+            internet_active: self.internet_active,
+            use_net_settings: self.use_net_settings,
+        });
+        k_config
     }
 
     pub fn update(&mut self, message: Message) -> UpdateResult {
@@ -170,7 +164,7 @@ impl NetworkStage {
 
     pub fn view(&self) -> iced::Element<'_, Message> {
         let next_button =
-            if (self.state == State::Cheking) || (!self.internet_active && self.reqire_network) {
+            if (self.state == State::Cheking) || (!self.internet_active && REQIRE_NETWORK) {
                 widget::button(widget::text(t!("button.next")))
             } else {
                 widget::button(widget::text(t!("button.next"))).on_press(Message::Next)

src/stages/partition/mod.rs

@@ -24,11 +24,13 @@ use crate::kira_color_bar;
 use crate::kira_disk_layout::{BlkDev, FSType, PartInfo, PartLayout};
 use crate::kira_size::KiraSize;
 use crate::kira_sysinfo;
-use crate::stage::{StageAction, StageResult};
+use crate::stage::{KiraConfig, StageAction};
 use iced::{Alignment, Color, Element, Length, widget};
 use log;
 use rust_i18n::t;
-use toml::Table;
+
+const MIN_DISK_SIZE_MB: u64 = 8192;
+const EFI_SIZE_MB: u64 = 128;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum SwapMode {
@@ -68,6 +70,8 @@ fn part_type_to_color(t: &FSType) -> Color {
     }
 }
 
+/// Converts PartInfo into data for ColorBar widget
+///
 fn part_to_ct_params(part: &PartInfo, dev_size: KiraSize) -> (String, u16, Color) {
     let fill_ratio: u16 = ((part.size.b() as f32 / dev_size.b() as f32) * 11.0) as u16;
     let fill_ratio = fill_ratio.max(1);
@@ -75,20 +79,36 @@ fn part_to_ct_params(part: &PartInfo, dev_size: KiraSize) -> (String, u16, Color
     (part.to_string(), fill_ratio, part_color)
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub struct PartitionStageResult {
+    pub swap_mode: SwapMode,
+    pub swap_size: KiraSize,
+    pub efi_size: KiraSize,
+    pub use_zram: bool,
+    pub secure_boot: bool,
+    pub encrypt_drive: bool,
+    pub password: Option<String>,
+    pub part_layout: PartLayout,
+}
+
 #[derive(Debug, Clone)]
 pub struct PartitionStage {
     device: Option<BlkDev>,
     devices: Vec<BlkDev>,
     swap_mode: Option<SwapMode>,
+    efi_size: KiraSize,
     use_zram: bool,
     secure_boot: bool,
+    encrypt_drive: bool,
     secure_boot_in_setup_mode: bool,
     custom_swap_size_mb: u32,
     custom_swap_size_str: String,
     selected_disk_parts: Option<Vec<(String, u16, Color)>>,
     generated_disk_parts: Option<Vec<(String, u16, Color)>>,
+    generated_part_layout: Option<PartLayout>,
     system_ram_size: KiraSize,
     vram_of_all_gpus_size: KiraSize,
+    k_config: KiraConfig,
 }
 
 #[derive(Debug, Clone)]
@@ -97,6 +117,7 @@ pub enum Message {
     SelectSwapMode(SwapMode),
     ToggleZram(bool),
     ToggleSecureBoot(bool),
+    ToggleEncrypDrive(bool),
     SwapSizeFieldChange(String),
     SwapSizeIncrement,
     SwapSizeDecrement,
@@ -105,18 +126,12 @@ pub enum Message {
 }
 
 impl PartitionStage {
-    pub fn new(toml_config: &Table) -> Result<Self, String> {
+    pub fn new(k_config: KiraConfig) -> Result<Self, String> {
         let maybe_dev_list = BlkDev::list_sys_blk_dev();
         log::info!("hiii from partition");
-        let min_disk_size_mb = toml_config
-            .get("partition")
-            .and_then(|v| v.as_table())
-            .and_then(|v| v.get("min_disk_size_mb"))
-            .and_then(|v| v.as_integer())
-            .unwrap_or(8192);
-
-        let min_disk_size: KiraSize = KiraSize::new_mb(min_disk_size_mb.try_into().unwrap_or(8192));
 
+        let min_disk_size: KiraSize = KiraSize::new_mb(MIN_DISK_SIZE_MB);
+        let efi_size: KiraSize = KiraSize::new_mb(EFI_SIZE_MB);
 
         let sec_boot_setup = match kira_sysinfo::get_secure_boot_status() {
             Ok(sb_status) => sb_status.setup_mode,
@@ -152,13 +167,17 @@ impl PartitionStage {
                     swap_mode: Some(SwapMode::SwapNoHibernate),
                     use_zram: true,
                     secure_boot: false,
+                    encrypt_drive: false,
                     secure_boot_in_setup_mode: sec_boot_setup,
                     custom_swap_size_mb: 1024,
                     custom_swap_size_str: "1024MB".into(),
+                    efi_size: efi_size,
                     selected_disk_parts: None,
                     generated_disk_parts: None,
+                    generated_part_layout: None,
                     system_ram_size: system_ram_size,
                     vram_of_all_gpus_size: vram_of_all_gpus_size,
+                    k_config: k_config,
                 })
             }
             Err(ex) => Err(ex),
@@ -204,35 +223,42 @@ impl PartitionStage {
     fn gen_layout(&mut self) {
         if let Some(dev) = self.device.clone() {
             let swap_size: KiraSize = self.get_swap_size();
+            let patr_layout = PartLayout::gen_kira_layout(
+                dev.clone(),
+                self.efi_size,
+                swap_size,
+                None,
+                Some("lz4".into()),
+            );
             self.generated_disk_parts = Some(
-                PartLayout::gen_classic_layout(dev.clone(), KiraSize::new_mb(512), swap_size)
+                patr_layout
                     .part_list
                     .iter()
                     .map(|part_info| part_to_ct_params(part_info, dev.size))
                     .collect(),
             );
+            self.generated_part_layout = Some(patr_layout);
         }
     }
 
-    fn gen_result(&self) -> StageResult {
-        let swap_size: KiraSize = self.get_swap_size();
-        let dev_name = self
-            .device
+    fn gen_result(&mut self) -> KiraConfig {
+        let disk_layout = self
+            .generated_part_layout
             .clone()
-            .expect("Device should be selected!")
-            .name;
-        StageResult::new("partition")
-            .add_val_string("device", dev_name)
-            .add_val_string(
-                "swap_mode",
-                self.swap_mode
-                    .clone()
-                    .unwrap_or(SwapMode::NoSwap)
-                    .to_string(),
-            )
-            .add_val_u64("swap_size_mb", swap_size.mb())
-            .add_val_bool("use_zram", self.use_zram)
-            .add_val_bool("secure_boot", self.secure_boot)
+            .expect("Layout must be generated!");
+
+        self.k_config.res_partition = Some(PartitionStageResult {
+            swap_mode: self.swap_mode.clone().unwrap(),
+            swap_size: self.get_swap_size(),
+            efi_size: self.efi_size,
+            use_zram: self.use_zram,
+            secure_boot: self.secure_boot,
+            encrypt_drive: true,
+            password: Some("123456".to_string()),
+            part_layout: disk_layout,
+        });
+
+        self.k_config.clone()
     }
 
     pub fn update(&mut self, message: Message) -> StageAction {
@@ -252,33 +278,38 @@ impl PartitionStage {
                     }
                 };
 
-                let swap_size: KiraSize = self.get_swap_size();
+                // let swap_size: KiraSize = self.get_swap_size();
 
-                self.generated_disk_parts = Some(
-                    PartLayout::gen_classic_layout(dev.clone(), KiraSize::new_mb(512), swap_size)
-                        .part_list
-                        .iter()
-                        .map(|part_info| part_to_ct_params(part_info, dev.size))
-                        .collect(),
-                );
+                // self.generated_disk_parts = Some(
+                //     PartLayout::gen_kira_layout(dev.clone(), self.efi_size, swap_size)
+                //         .part_list
+                //         .iter()
+                //         .map(|part_info| part_to_ct_params(part_info, dev.size))
+                //         .collect(),
+                // );
 
                 self.device = Some(dev);
+                self.gen_layout();
                 StageAction::None
-            },
+            }
             Message::SelectSwapMode(sm) => {
                 self.swap_mode = Some(sm);
                 self.gen_layout();
                 StageAction::None
-            },
+            }
             Message::ToggleSecureBoot(t) => {
                 self.secure_boot = t;
                 StageAction::None
-            },
+            }
+            Message::ToggleEncrypDrive(t) => {
+                self.encrypt_drive = t;
+                StageAction::None
+            }
             Message::ToggleZram(t) => {
                 self.use_zram = t;
                 self.gen_layout();
                 StageAction::None
-            },
+            }
             Message::SwapSizeIncrement => {
                 self.custom_swap_size_mb = (self.custom_swap_size_mb / 1024u32)
                     .strict_mul(1024u32)
@@ -286,7 +317,7 @@ impl PartitionStage {
                 self.custom_swap_size_str = format!("{}MB", self.custom_swap_size_mb);
                 self.gen_layout();
                 StageAction::None
-            },
+            }
             Message::SwapSizeDecrement => {
                 self.custom_swap_size_mb = (self.custom_swap_size_mb / 1024u32)
                     .strict_mul(1024u32)
@@ -294,7 +325,7 @@ impl PartitionStage {
                 self.custom_swap_size_str = format!("{}MB", self.custom_swap_size_mb);
                 self.gen_layout();
                 StageAction::None
-            },
+            }
             Message::SwapSizeFieldChange(f_v) => {
                 let mut only_num = f_v.trim().to_string();
                 only_num.retain(char::is_numeric);
@@ -302,7 +333,7 @@ impl PartitionStage {
                 self.custom_swap_size_str = format!("{}MB", self.custom_swap_size_mb);
                 self.gen_layout();
                 StageAction::None
-            },
+            }
             Message::Back => StageAction::Back,
             Message::Next => StageAction::Next(self.gen_result()),
         }
@@ -344,10 +375,12 @@ impl PartitionStage {
         let selected_dev_content = widget::column![selected_dev_text, selected_dev_content];
 
         let use_sec_boot_checkbox = if self.secure_boot_in_setup_mode {
+            widget::checkbox(self.secure_boot)
+                .label(t!("partition.use_secure_boot"))
+                .on_toggle(Message::ToggleSecureBoot)
+        } else {
             widget::checkbox(self.secure_boot).label(t!("partition.use_secure_boot"))
-                        .on_toggle(Message::ToggleSecureBoot)
-        }
-        else {widget::checkbox(self.secure_boot).label(t!("partition.use_secure_boot"))};
+        };
 
         widget::column![
             widget::container(
@@ -376,6 +409,10 @@ impl PartitionStage {
                     widget::rule::horizontal(2),
                     use_sec_boot_checkbox,
                     widget::rule::horizontal(2),
+                    widget::checkbox(self.encrypt_drive)
+                        .label(t!("partition.encrypt_drive"))
+                        .on_toggle(Message::ToggleEncrypDrive),
+                    widget::rule::horizontal(2),
                     selected_dev_content,
                     dev_parts_content,
                 ]

src/stages/security/mod.rs

@@ -18,7 +18,7 @@
     This is Security stage, setup users logins and such
 */
 
-use crate::stage::{StageAction, StageResult};
+use crate::stage::{KiraConfig, StageAction};
 use iced::{Alignment, Color, widget};
 use rust_i18n::t;
 
@@ -69,6 +69,15 @@ pub struct SecurityStage {
     root_pass_is_secure: bool,
     user_password_strenght: PasswordStrenght,
     root_password_strenght: PasswordStrenght,
+    k_config: KiraConfig,
+}
+
+#[derive(Debug, Clone)]
+pub struct SecurityStageResult {
+    pub user_name: String,
+    pub user_full_name: String,
+    pub user_password: String,
+    pub root_password: String,
 }
 
 #[derive(Debug, Clone)]
@@ -93,7 +102,7 @@ fn retain_first_n(s: &str, n: usize) -> &str {
 }
 
 impl SecurityStage {
-    pub fn new() -> Self {
+    pub fn new(k_config: KiraConfig) -> Self {
         Self {
             user_name: "".into(),
             user_full_name: "".into(),
@@ -104,16 +113,18 @@ impl SecurityStage {
             root_pass_is_secure: true,
             user_password_strenght: PasswordStrenght::Low,
             root_password_strenght: PasswordStrenght::Low,
+            k_config: k_config,
         }
     }
 
-    fn gen_result(&self) -> StageResult {
-        StageResult::new("security")
-            .add_val_string("user_name", self.user_name.clone())
-            .add_val_string("user_full_name", self.user_full_name.clone())
-            .add_val_string("user_full_name", self.user_full_name.clone())
-            .add_val_string("user_password", self.user_password.clone())
-            .add_val_string("root_password", self.root_password.clone())
+    fn gen_result(&mut self) -> KiraConfig {
+        self.k_config.res_security = Some(SecurityStageResult {
+            user_name: self.user_name.clone(),
+            user_full_name: self.user_full_name.clone(),
+            user_password: self.user_password.clone(),
+            root_password: self.root_password.clone(),
+        });
+        self.k_config.clone()
     }
 
     pub fn update(&mut self, message: Message) -> StageAction {

src/stages/timezone/mod.rs

@@ -18,9 +18,9 @@
    This is TimeZone stage, used to select timezone
 */
 
-use log;
-use crate::stage::{StageAction, StageResult};
+use crate::stage::{KiraConfig, StageAction};
 use iced::{Alignment, Length, widget};
+use log;
 use rust_i18n::t;
 use std::collections::HashMap;
 
@@ -58,6 +58,12 @@ pub struct TimeZoneStage {
     zone_id: Option<usize>,
     selected_zone: Option<TimeZoneData>,
     selected_zone_text: String,
+    k_config: KiraConfig,
+}
+
+#[derive(Debug, Clone)]
+pub struct TimeZoneStageResult {
+    pub time_zone: TimeZoneData,
 }
 
 #[derive(Debug, Clone)]
@@ -100,7 +106,7 @@ fn get_timezones_blocking() -> Result<Vec<TimeZoneData>, String> {
 }
 
 impl TimeZoneStage {
-    pub fn new() -> Self {
+    pub fn new(k_config: KiraConfig) -> Self {
         match get_timezones_blocking() {
             Ok(time_zones_data_list) => {
                 let mut time_zones_map: HashMap<String, Vec<String>> = HashMap::new();
@@ -125,6 +131,7 @@ impl TimeZoneStage {
                     zone_id: None,
                     selected_zone: None,
                     selected_zone_text: String::new(),
+                    k_config: k_config,
                 }
             }
             Err(ex) => {
@@ -140,20 +147,20 @@ impl TimeZoneStage {
                     zone_id: None,
                     selected_zone: None,
                     selected_zone_text: String::new(),
+                    k_config: k_config,
                 }
             }
         }
     }
 
-    fn gen_result(&self) -> StageResult {
-        if let Some(time_zone) = &self.selected_zone {
-            StageResult::new("time_zone")
-            .add_val_string("name", time_zone.to_string())
-            .add_val_string("region", time_zone.region.clone())
-            .add_val_string("zone", time_zone.zone.clone())
-        } else {
-            StageResult::new("time_zone")
-        }
+    fn gen_result(&mut self) -> KiraConfig {
+        self.k_config.res_timezone = Some(TimeZoneStageResult {
+            time_zone: self
+                .selected_zone
+                .clone()
+                .expect("Timezone must be selected!"),
+        });
+        self.k_config.clone()
     }
 
     pub fn update(&mut self, message: Message) -> StageAction {
@@ -201,10 +208,14 @@ impl TimeZoneStage {
                     widget::row![
                         kira_scroll_list::list_view(&self.regions, self.region_id, Length::Shrink)
                             .map(Message::SelectRegion),
-                        kira_scroll_list::list_view(&self.zones, self.zone_id, Length::FillPortion(1))
-                            .map(Message::SelectZone),
+                        kira_scroll_list::list_view(
+                            &self.zones,
+                            self.zone_id,
+                            Length::FillPortion(1)
+                        )
+                        .map(Message::SelectZone),
                     ]
-                    .padding([0,10])
+                    .padding([0, 10])
                     .spacing(10)
                     .height(Length::Shrink),
                     widget::text(self.selected_zone_text.clone())

src/stages/welcome/mod.rs

@@ -1,26 +1,27 @@
-    // <Kira Installer - universal Linux installer.>
-    // Copyright (C) <2026>  <Kira Foundation>
+// <Kira Installer - universal Linux installer.>
+// Copyright (C) <2026>  <Kira Foundation>
 
-    // This program is free software: you can redistribute it and/or modify
-    // it under the terms of the GNU General Public License as published by
-    // the Free Software Foundation, either version 3 of the License, or
-    // (at your option) any later version.
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
 
-    // This program is distributed in the hope that it will be useful,
-    // but WITHOUT ANY WARRANTY; without even the implied warranty of
-    // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    // GNU General Public License for more details.
-
-    // You should have received a copy of the GNU General Public License
-    // along with this program.  If not, see <https://www.gnu.org/licenses/>.
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
 
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 /*
-    This is Welcome stage, used to greet used and allow user to choose program language
- */
+   This is Welcome stage, used to greet used and allow user to choose program language
+*/
 
-
-use crate::{stage::{StageAction, StageResult}, kira_theming};
+use crate::{
+    kira_theming,
+    stage::{KiraConfig, StageAction},
+};
 use iced::{Alignment, widget};
 use rust_i18n::t;
 
@@ -36,10 +37,17 @@ impl std::fmt::Display for LocData {
     }
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub struct WelcomeStageResult {
+    pub loc_code: String,
+    pub loc_name: String,
+}
+
 #[derive(Debug, Clone)]
 pub struct WelcomeStage {
     locale: Option<LocData>,
     locales: Vec<LocData>,
+    k_config: KiraConfig,
 }
 
 #[derive(Debug, Clone)]
@@ -50,8 +58,7 @@ pub enum Message {
 }
 
 impl WelcomeStage {
-    pub fn new() -> Self {
-        
+    pub fn new(k_config: KiraConfig) -> Self {
         Self {
             locale: Some(LocData {
                 name: "English".into(),
@@ -64,19 +71,23 @@ impl WelcomeStage {
                     code: s.to_string(),
                 })
                 .collect(),
+            k_config: k_config,
         }
     }
 
-    fn gen_result(&self) -> StageResult {
-        if let Some(loc) = &self.locale {
-            StageResult::new("welcome")
-            .add_val_string("loc_code", loc.code.clone())
-            .add_val_string("loc_name", loc.name.clone())
+    fn gen_result(&mut self) -> KiraConfig {
+        self.k_config.res_welcome = Some(if let Some(loc) = &self.locale {
+            WelcomeStageResult {
+                loc_code: loc.code.clone(),
+                loc_name: loc.name.clone(),
+            }
         } else {
-            StageResult::new("welcome")
-            .add_val_string("loc_code", "en".to_string())
-            .add_val_string("loc_name", "English".to_string())
-        }
+            WelcomeStageResult {
+                loc_code: "en".to_string(),
+                loc_name: "English".to_string(),
+            }
+        });
+        self.k_config.clone()
     }
 
     pub fn update(&mut self, message: Message) -> StageAction {
@@ -96,8 +107,7 @@ impl WelcomeStage {
         let exit_button = widget::button(widget::text(t!("button.exit"))).on_press(Message::Exit);
 
         // Embed the image bytes into the executable
-        let welcom_logo_handle =
-            widget::image::Handle::from_bytes(kira_theming::get_logo_bytes());
+        let welcom_logo_handle = widget::image::Handle::from_bytes(kira_theming::get_logo_bytes());
 
         widget::column![
             widget::container(