diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..96ef6c0
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+/target
+Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..ac5285a
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,7 @@
+[package]
+name = "ansitui"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+tui = { version = "0.14.0", default-features = false }
diff --git a/ansi.py b/ansi.py
new file mode 100755
index 0000000..5bd301f
--- /dev/null
+++ b/ansi.py
@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+
+# for code in range(107):
+#     print(f"\x1b[{code}mTHIS IS TEXT\x1b[0m")
+
+# for z in range(255):
+#     print(
+#         f"\x1b[{38};{5};{z};{1};{7};{3};{5};{4}mTEXT \\x1b[{38};{5};{z}m\\1xb[0m\x1b[0m")
+
+llist = [27, 49, 49, 49, 51, 49, 109, 49, 50, 51, 52, 27, 48, 109, ]
+
+for l in llist:
+    print(chr(l))
diff --git a/archlinux.ascii b/archlinux.ascii
new file mode 100644
index 0000000..5355dd1
--- /dev/null
+++ b/archlinux.ascii
@@ -0,0 +1,15 @@
+              ..              
+              cl              
+             :ooc             
+            ;oooo:            
+           .looooo:           
+          ;c;:looooc          
+         :ooooooooooc         
+        :ooooooooooool        
+       coooool;;loooool.      
+     .looooo'    .oooooo.     
+    .ooooooc      ;oooocl'    
+   'ooooooo:      'ooooo:,    
+  ,oool:,..        ..,:looo;  
+ :c,.                    .,c: 
+..                          .'
diff --git a/src/ansi.rs b/src/ansi.rs
new file mode 100644
index 0000000..275637c
--- /dev/null
+++ b/src/ansi.rs
@@ -0,0 +1,209 @@
+#![allow(dead_code, unused_mut, unused_imports)]
+use crate::code::AnsiCode;
+use crate::color::AnsiColor;
+use crate::error::Error;
+use crate::stack::Stack;
+use std::slice::Iter;
+use tui::{
+    style::{Color, Modifier, Style},
+    text::{Span, Spans, Text},
+};
+
+impl Stack<u8> {
+    pub fn parse_usize(&mut self) -> usize {
+        let mut num: usize = 0 as usize;
+        for n in self.iter() {
+            // num = num * 10 + (n.saturating_sub(48_u8)) as usize
+            num = num * 10 + (n - 48_u8) as usize
+        }
+        self.clear();
+        num
+    }
+    pub fn parse_color(&mut self) -> Result<Color, Error> {
+        let mut color: Color;
+        let length = self.len();
+        if length == 1 {
+            color = Color::Indexed(self.pop().expect("Shouldn't happen len check in place"))
+        } else if length == 3 {
+            let b = self.pop().unwrap();
+            let g = self.pop().unwrap();
+            let r = self.pop().unwrap();
+            color = Color::Rgb(r, g, b);
+        } else {
+            return Err(Error::TempError);
+        }
+        self.clear();
+        Ok(color)
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+#[repr(u8)]
+pub enum AnsiColorMode {
+    RGB = 2,
+    Indexed = 5,
+}
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+#[repr(u8)]
+pub enum AnsiColorLayer {
+    Background,
+    Foreground,
+}
+
+#[derive(Debug)]
+pub struct AnsiGraphicsStack {
+    stack: Stack<usize>,
+}
+
+impl AnsiGraphicsStack {
+    pub fn new() -> Self {
+        Self {
+            stack: Stack::new(),
+        }
+    }
+    pub fn push(&mut self, sequence: usize) {
+        self.stack.push(sequence);
+    }
+    pub fn iter(&mut self) -> Iter<usize> {
+        self.stack.iter()
+    }
+    pub fn parse_ansi(&mut self) -> Style {
+        let mut style = Style::default();
+        let mut color_stack: Stack<u8> = Stack::new();
+        let mut color_parse: bool = false;
+        let mut color_parse_mode: Option<AnsiColorMode> = None;
+        let mut last_sequence: usize = 0;
+        let mut color_layer: Option<AnsiColorLayer> = None;
+        // println!("{:?}", self);
+        for sequence in self.iter().cloned() {
+            if color_parse {
+                if sequence < 255 {
+                    if AnsiCode::from(last_sequence as u8) == AnsiCode::ForegroundColorIndex
+                        || AnsiCode::from(last_sequence as u8) == AnsiCode::BackgroundColorIndex
+                        || sequence == AnsiColorMode::RGB as usize
+                    {
+                        color_parse_mode = Some(AnsiColorMode::RGB)
+                    } else if AnsiCode::from(last_sequence as u8) == AnsiCode::ForegroundColorIndex
+                        || AnsiCode::from(last_sequence as u8) == AnsiCode::BackgroundColorIndex
+                        || sequence == AnsiColorMode::Indexed as usize
+                    {
+                        color_parse_mode = Some(AnsiColorMode::Indexed)
+                    } else if color_parse_mode.is_some() {
+                        let mode = color_parse_mode.unwrap();
+                        match mode {
+                            AnsiColorMode::Indexed => {
+                                color_stack.push(sequence as u8);
+                                match color_layer.unwrap() {
+                                    AnsiColorLayer::Foreground => {
+                                        style = style.fg(color_stack.parse_color().unwrap())
+                                    }
+                                    AnsiColorLayer::Background => {
+                                        style = style.bg(color_stack.parse_color().unwrap())
+                                    }
+                                }
+                            }
+                            AnsiColorMode::RGB => {
+                                color_stack.push(sequence as u8);
+                                if color_stack.len() == 3 {
+                                    match color_layer.unwrap() {
+                                        AnsiColorLayer::Foreground => {
+                                            style = style.fg(color_stack.parse_color().unwrap())
+                                        }
+                                        AnsiColorLayer::Background => {
+                                            style = style.bg(color_stack.parse_color().unwrap())
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    } else {
+                        color_parse = false;
+                    }
+                } else {
+                    // println!("stop color index");
+                    color_parse = false;
+                }
+                last_sequence = sequence;
+                continue;
+            }
+            let code = AnsiCode::from(sequence as u8);
+            match code {
+                AnsiCode::Reset => style = Style::default(),
+                AnsiCode::Bold => style = style.add_modifier(Modifier::BOLD),
+                AnsiCode::Faint => style = style.add_modifier(Modifier::DIM),
+                AnsiCode::Italic => style = style.add_modifier(Modifier::ITALIC),
+                AnsiCode::Underline => style = style.add_modifier(Modifier::UNDERLINED),
+                AnsiCode::SlowBlink => style = style.add_modifier(Modifier::SLOW_BLINK),
+                AnsiCode::RapidBlink => style = style.add_modifier(Modifier::RAPID_BLINK),
+                AnsiCode::Reverse => style = style.add_modifier(Modifier::REVERSED),
+                AnsiCode::Conceal => style = style.add_modifier(Modifier::HIDDEN),
+                AnsiCode::CrossedOut => style = style.add_modifier(Modifier::CROSSED_OUT),
+                AnsiCode::DefaultForegroundColor => style = style.fg(Color::Reset),
+                AnsiCode::DefaultBackgroundColor => style = style.bg(Color::Reset),
+                AnsiCode::ForegroundColorIndex => {
+                    // println!("foreground color index");
+                    color_parse = true;
+                    color_layer = Some(AnsiColorLayer::Foreground)
+                }
+                AnsiCode::BackgroundColorIndex => {
+                    // println!("background color index");
+                    color_parse = true;
+                    color_layer = Some(AnsiColorLayer::Background)
+                }
+                AnsiCode::ForegroundColor(color) => style = style.fg(Color::from(color)),
+                AnsiCode::BackgroundColor(color) => style = style.bg(Color::from(color)),
+                _ => (),
+            }
+            last_sequence = sequence;
+        }
+        self.stack.clear();
+        println!("style {:?}", style);
+        // println!("-----------------------------");
+        style
+    }
+}
+
+pub fn ansi_to_text<'t, B: AsRef<[u8]>>(bytes: B) -> Result<Text<'t>, Error> {
+    let mut reader = bytes.as_ref().iter();
+    let mut buffer: Vec<Spans> = Vec::new();
+    let mut style: Option<Style> = None;
+    let mut ansi_stack: AnsiGraphicsStack = AnsiGraphicsStack::new();
+    let mut num_stack: Stack<u8> = Stack::new();
+    let mut graphics_start: bool = false;
+    let mut line_buffer = String::new();
+    // let mut last_byte: &u8 = reader.next().expect("Zero size bytes buffer");
+    let mut last_byte: &u8 = &0_u8;
+    for byte in reader {
+        match (last_byte, byte) {
+            (&b'\x1b', &b'[') => {
+                if style.is_some() {
+                    buffer.push(Spans::from(Span::styled(
+                        line_buffer.clone(),
+                        style.unwrap(),
+                    )));
+                }
+                graphics_start = true;
+            }
+            (_, code) => {
+                if graphics_start {
+                    if code == &b'm' {
+                        ansi_stack.push(num_stack.parse_usize());
+                        style = Some(ansi_stack.parse_ansi());
+                        graphics_start = false;
+                    } else if code == &b';' {
+                        ansi_stack.push(num_stack.parse_usize());
+                    } else {
+                        num_stack.push(*code);
+                    }
+                } else if code != &b'\x1b' {
+                    line_buffer.push(*code as char)
+                }
+                last_byte = code;
+            }
+        }
+    }
+    println!("{:?}", buffer);
+
+    Ok(buffer.into())
+}
diff --git a/src/code.rs b/src/code.rs
new file mode 100644
index 0000000..fee65fd
--- /dev/null
+++ b/src/code.rs
@@ -0,0 +1,87 @@
+use crate::color::AnsiColor;
+#[derive(Debug, PartialEq)]
+#[repr(u8)]
+#[allow(dead_code)]
+pub enum AnsiCode {
+    Reset,
+    Bold,
+    Faint,
+    Italic,
+    Underline,
+    SlowBlink,
+    RapidBlink,
+    Reverse,
+    Conceal,
+    CrossedOut,
+    PrimaryFont,
+    AlternateFont,
+    AlternateFonts(u8), // = 11..19, // from 11 to 19
+    Fraktur,
+    BoldOff,
+    Normal,
+    NotItalic,
+    UnderlineOff,
+    BlinkOff,
+    // 26 ?
+    InvertOff,
+    Reveal,
+    CrossedOutOff,
+
+    ForegroundColor(AnsiColor), //, 31..37//Issue 60553 /~https://github.com/rust-lang/rust/issues/60553
+    ForegroundColorIndex,
+    DefaultForegroundColor,
+    BackgroundColor(AnsiColor), // 41..47
+    BackgroundColorIndex,
+    DefaultBackgroundColor, // 49
+}
+
+impl From<u8> for AnsiCode {
+    fn from(code: u8) -> Self {
+        match code {
+            0 => AnsiCode::Reset,
+            1 => AnsiCode::Bold,
+            2 => AnsiCode::Faint,
+            3 => AnsiCode::Italic,
+            4 => AnsiCode::Underline,
+            5 => AnsiCode::SlowBlink,
+            6 => AnsiCode::RapidBlink,
+            7 => AnsiCode::Reverse,
+            8 => AnsiCode::Conceal,
+            9 => AnsiCode::CrossedOut,
+            10 => AnsiCode::PrimaryFont,
+            11 => AnsiCode::AlternateFont,
+            // AnsiCode::// AlternateFont = 11..19, // from 11 to 19
+            20 => AnsiCode::Fraktur,
+            21 => AnsiCode::BoldOff,
+            22 => AnsiCode::Normal,
+            23 => AnsiCode::NotItalic,
+            24 => AnsiCode::UnderlineOff,
+            25 => AnsiCode::BlinkOff,
+            // 26 ?
+            27 => AnsiCode::InvertOff,
+            28 => AnsiCode::Reveal,
+            29 => AnsiCode::CrossedOutOff,
+            30 => AnsiCode::ForegroundColor(AnsiColor::Black),
+            31 => AnsiCode::ForegroundColor(AnsiColor::Red),
+            32 => AnsiCode::ForegroundColor(AnsiColor::Green),
+            33 => AnsiCode::ForegroundColor(AnsiColor::Yellow),
+            34 => AnsiCode::ForegroundColor(AnsiColor::Blue),
+            35 => AnsiCode::ForegroundColor(AnsiColor::Magenta),
+            36 => AnsiCode::ForegroundColor(AnsiColor::Cyan),
+            37 => AnsiCode::ForegroundColor(AnsiColor::Gray),
+            38 => AnsiCode::ForegroundColorIndex,
+            39 => AnsiCode::DefaultForegroundColor,
+            40 => AnsiCode::BackgroundColor(AnsiColor::Black),
+            41 => AnsiCode::BackgroundColor(AnsiColor::Red),
+            42 => AnsiCode::BackgroundColor(AnsiColor::Green),
+            43 => AnsiCode::BackgroundColor(AnsiColor::Yellow),
+            44 => AnsiCode::BackgroundColor(AnsiColor::Blue),
+            45 => AnsiCode::BackgroundColor(AnsiColor::Magenta),
+            46 => AnsiCode::BackgroundColor(AnsiColor::Cyan),
+            47 => AnsiCode::BackgroundColor(AnsiColor::Gray),
+            48 => AnsiCode::BackgroundColorIndex,
+            49 => AnsiCode::DefaultBackgroundColor,
+            _ => AnsiCode::Reset,
+        }
+    }
+}
diff --git a/src/color.rs b/src/color.rs
new file mode 100644
index 0000000..330883d
--- /dev/null
+++ b/src/color.rs
@@ -0,0 +1,66 @@
+use tui::style::Color;
+#[derive(Debug, PartialEq)]
+pub enum AnsiColor {
+    Black,
+    Red,
+    Green,
+    Yellow,
+    Blue,
+    Magenta,
+    Cyan,
+    Gray,     // white
+    DarkGray, // lightblack
+    LightRed,
+    LightGreen,
+    LightYellow,
+    LightBlue,
+    LightMagenta,
+    LightCyan,
+    White,           // lightwhite
+    RGB(u8, u8, u8), // TrueColor
+    Indexed(u8),     // 8-bit color
+}
+
+impl From<AnsiColor> for Color {
+    fn from(ansi: AnsiColor) -> Self {
+        match ansi {
+            AnsiColor::Black => Color::Black,
+            AnsiColor::Red => Color::Red,
+            AnsiColor::Green => Color::Green,
+            AnsiColor::Yellow => Color::Yellow,
+            AnsiColor::Blue => Color::Blue,
+            AnsiColor::Magenta => Color::Magenta,
+            AnsiColor::Cyan => Color::Cyan,
+            AnsiColor::Gray => Color::Gray,
+            AnsiColor::DarkGray => Color::DarkGray,
+            AnsiColor::LightRed => Color::LightRed,
+            AnsiColor::LightGreen => Color::LightGreen,
+            AnsiColor::LightYellow => Color::LightYellow,
+            AnsiColor::LightBlue => Color::LightBlue,
+            AnsiColor::LightMagenta => Color::LightMagenta,
+            AnsiColor::LightCyan => Color::LightCyan,
+            AnsiColor::White => Color::White,
+            AnsiColor::RGB(r, g, b) => Color::Rgb(r, g, b),
+            AnsiColor::Indexed(c) => Color::Indexed(c),
+        }
+    }
+}
+// pub fn ansi_to_color(ansi: u8) -> AnsiColor {
+//     match ansi {
+//         30 | 40 => AnsiColor::Black,
+//         31 | 41 => AnsiColor::Red,
+//         32 | 42 => AnsiColor::Green,
+//         33 | 43 => AnsiColor::Yellow,
+//         34 | 44 => AnsiColor::Blue,
+//         35 | 45 => AnsiColor::Gray,
+//         90 | 100 => AnsiColor::DarkGray,
+//         91 | 101 => AnsiColor::LightRed,
+//         92 | 102 => AnsiColor::LightGreen,
+//         93 | 103 => AnsiColor::LightYellow,
+//         94 | 104 => AnsiColor::LightBlue,
+//         95 | 105 => AnsiColor::LightMagenta,
+//         96 | 106 => AnsiColor::LightCyan,
+//         97 | 107 => AnsiColor::White,
+//         _ => AnsiColor::Black,
+//     }
+// }
diff --git a/src/error.rs b/src/error.rs
new file mode 100644
index 0000000..d62b315
--- /dev/null
+++ b/src/error.rs
@@ -0,0 +1,8 @@
+#[allow(dead_code)]
+#[derive(Debug)]
+pub enum Error {
+    StackLocked,
+    StackUnlocked,
+    InvalidAnsi,
+    TempError,
+}
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..60b76c2
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,8 @@
+#![allow(dead_code, unused_mut, unused_imports)]
+mod ansi;
+mod code;
+mod color;
+mod error;
+mod stack;
+mod style;
+mod tests;
diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..dcc2722
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,17 @@
+mod ansi;
+mod code;
+mod color;
+mod error;
+mod stack;
+mod style;
+mod tests;
+use std::io::Read;
+
+use ansi::ansi_to_text;
+pub fn main() {
+    let mut file = std::fs::File::open("log").unwrap();
+    // let mut file = std::fs::File::open("archlinux.ascii").unwrap();
+    let mut buffer: Vec<u8> = Vec::new();
+    file.read_to_end(&mut buffer).unwrap();
+    let _text = ansi_to_text(buffer);
+}
diff --git a/src/stack.rs b/src/stack.rs
new file mode 100644
index 0000000..30ba94a
--- /dev/null
+++ b/src/stack.rs
@@ -0,0 +1,48 @@
+// use crate::error::Error;
+use std::slice::Iter;
+
+#[derive(Debug)]
+pub struct Stack<T> {
+    st: Vec<T>,
+    lock: bool,
+}
+
+impl<T> Stack<T> {
+    pub fn new() -> Self {
+        Self {
+            st: Vec::<T>::new(),
+            lock: false,
+        }
+    }
+    pub fn push(&mut self, value: T) {
+        self.st.push(value);
+    }
+    pub fn pop(&mut self) -> Option<T> {
+        self.st.pop()
+    }
+    pub fn iter(&mut self) -> Iter<T> {
+        self.st.iter()
+    }
+    pub fn len(&mut self) -> usize {
+        self.st.len()
+    }
+    // pub fn append(&mut self, other: &mut Vec<T>) {
+    //     self.st.append(other)
+    // }
+    pub fn clear(&mut self) {
+        self.st.clear();
+    }
+    // pub fn lock(&mut self) -> Result<(), Error> {
+    //     if self.lock {
+    //         Err(Error::StackLocked)
+    //     } else {
+    //         Ok(())
+    //     }
+    // }
+    // pub fn unlock(&mut self) -> Result<(), Error> {
+    //     Ok(self.lock = false)
+    // }
+    // pub fn is_locked(&self) -> bool {
+    //     self.lock
+    // }
+}
diff --git a/src/style.rs b/src/style.rs
new file mode 100644
index 0000000..8ee847f
--- /dev/null
+++ b/src/style.rs
@@ -0,0 +1,40 @@
+// use crate::ansi::AnsiGraphicsStack;
+// use crate::code::AnsiCode;
+// use crate::color::AnsiColor;
+// use tui::style::Style;
+
+// pub struct AnsiStyle {
+//     foreground: Option<AnsiColor>,
+//     background: Option<AnsiColor>,
+//     effect: Vec<u8>,
+// }
+
+// impl AnsiStyle {
+//     pub fn new() -> Self {
+//         Self {
+//             foreground: None,
+//             background: None,
+//             effect: Vec::<u8>::new(),
+//         }
+//     }
+// }
+// impl From<AnsiStyle> for Style {
+//     fn from(ansi_style: AnsiStyle) -> Self {
+//         let style = Style::default();
+//         todo!();
+//     }
+// }
+
+// impl From<AnsiGraphicsStack> for AnsiStyle {
+//     fn from(stack: AnsiGraphicsStack) -> Self {
+//         AnsiStyle::new()
+//         // for style in stack.iter() {
+//         //     match style {
+//         //         1..=11 | 20..=25 | 27..=29 | 38 | 39 => {
+//         //             *style as AnsiCode;
+//         //         }
+//         //         _ => (),
+//         //     }
+//         // }
+//     }
+// }
diff --git a/src/tests.rs b/src/tests.rs
new file mode 100644
index 0000000..7f8c63f
--- /dev/null
+++ b/src/tests.rs
@@ -0,0 +1,7 @@
+#[cfg(test)]
+#[test]
+fn test_color() {
+    use crate::ansi_to_color;
+    use tui::style::Color;
+    assert_eq!(ansi_to_color(31_u8), Color::Red);
+}