diff --git a/.gitignore b/.gitignore
index d2ca5e9..7032593 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
-.env
 .venv
-app.db
-__pycache__
+app.log
+__pycache__/
+database.db
+.env
 flask_session
\ No newline at end of file
diff --git a/dockerfile b/dockerfile
index 88e9628..22d952d 100644
--- a/dockerfile
+++ b/dockerfile
@@ -10,7 +10,7 @@ COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
 # Copy the rest of the application code into the container
-COPY src/ ./src
+COPY src src
 
 # Expose the port the app runs on
 EXPOSE 5000
diff --git a/readme.md b/readme.md
index 6ce3e28..67fb375 100644
--- a/readme.md
+++ b/readme.md
@@ -2,6 +2,6 @@
 prismic is a simple messageboard made in python
 
 ## Planned features
-- [ ] user board creation
-- [ ] custom profiles
+- [x] user board creation
+- [x] custom profiles
 - [x] moderation tools
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index 2114d63..aade3db 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1,5 @@
-flask
-flask-session
\ No newline at end of file
+mysql-connector-python # only required for external mysql connection
+python-dotenv # only required if using .env file
+python-dateutil 
+flask-session
+flask
\ No newline at end of file
diff --git a/src/database.py b/src/database.py
index a203755..378be11 100644
--- a/src/database.py
+++ b/src/database.py
@@ -1,581 +1,185 @@
-import sqlite3, logging, os
+import os, hashlib, sqlite3, logging
+from os import getenv as env
+import mysql.connector
 
 
-# Configure logging
-logger = logging.getLogger(__name__)
+log = logging.getLogger(__name__)
+FETCHALL = 0
+FETCHONE = 1
 
 
 class Database:
-    def __init__(self, db_name):
-        # Initialize the database connection
-        logger.info("Initializing database connection...")
-        self.connection = sqlite3.connect(db_name, check_same_thread=False)
-        self.cursor = self.connection.cursor()
-        logger.info("Database connection established.")
+    def __init__(self):
+        self.connection = None
+        self.cursor = None
 
-        # Create users table if it doesn't exist
-        logger.info("Creating users table if it doesn't exist...")
-        self.cursor.execute('''
-            CREATE TABLE IF NOT EXISTS users (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                username TEXT NOT NULL UNIQUE,
-                password TEXT NOT NULL,
-                session TEXT,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    def connect_sqlite(self, db_path):
+        try:
+            self.connection = sqlite3.connect(db_path, check_same_thread=False)
+            self.cursor = self.connection.cursor()
+            log.info("Connected to SQLite database")
+        except sqlite3.Error as e:
+            log.error(f"SQLite connection error: {e}")
+            raise
+
+    def connect_mysql(self):
+        try:
+            self.connection = mysql.connector.connect(
+                host=env('MYSQL_HOST'),
+                user=env('MYSQL_USER'),
+                password=env('MYSQL_PASSWORD'),
+                database=env('MYSQL_DATABASE')
             )
-        ''')
-        logger.info("Users table created.")
-
-        # Create boards table if it doesn't exist
-        logger.info("Creating boards table if it doesn't exist...")
-        self.cursor.execute('''
-            CREATE TABLE IF NOT EXISTS boards (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                name TEXT NOT NULL UNIQUE,
-                owner_id INTEGER NOT NULL,
-                description TEXT,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (owner_id) REFERENCES users (id) ON DELETE SET NULL
-            )
-        ''')
-        logger.info("Boards table created.")
-
-        # Create posts table if it doesn't exist
-        logger.info("Creating posts table if it doesn't exist...")
-        self.cursor.execute('''
-            CREATE TABLE IF NOT EXISTS posts (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                user_id INTEGER NOT NULL,
-                board_id INTEGER NOT NULL,
-                content TEXT NOT NULL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                refence INTEGER,
-                FOREIGN KEY (refence) REFERENCES posts (id) ON DELETE CASCADE,
-                FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE SET NULL,
-                FOREIGN KEY (board_id) REFERENCES boards (id) ON DELETE CASCADE
-            )
-        ''')
-        logger.info("Posts table created.")
-
+            self.cursor = self.connection.cursor()
+            log.info("Connected to MySQL database")
+        except mysql.connector.Error as e:
+            log.error(f"MySQL connection error: {e}")
+            raise
 
     def close(self):
-        # Close the database connection
-        logger.info("Closing database connection...")
-        self.connection.commit()
-        self.connection.close()
-        logger.info("Database connection closed.")
+        if self.cursor:
+            self.cursor.close()
+        if self.connection:
+            self.connection.close()
+        log.warning("Database connection closed")
 
-
-    def create_user(self, username, password):
-        logger.info(f"Creating user: {username}")
-
-        # Check if the user already exists
-        logger.info(f"Checking if user {username} already exists...")
-        self.cursor.execute('''
-            SELECT * FROM users WHERE username = ?
-        ''', (username,))
-        user = self.cursor.fetchone()
-
-        if user:
-            logger.warning(f"User {username} already exists.")
-            return False
-        logger.info(f"User {username} does not exist.")
-
-        # Create a new user
-        self.cursor.execute('''
-            INSERT INTO users (username, password)
-            VALUES (?, ?)
-        ''', (username, password))
-
-        self.connection.commit()
-        logger.info(f"User {username} created.")
-        return True
-    
-
-    def get_user(self, username):
-        # Get user by username
-        logger.info(f"Getting user {username}...")
-        self.cursor.execute('''
-            SELECT * FROM users WHERE username = ?
-        ''', (username,))
-        user = self.cursor.fetchone()
-
-        if user:
-            logger.info(f"User {username} found.")
-            return user
-        logger.warning(f"User {username} not found.")
-        return None
-    
-
-    def create_board(self, name, description, owner_id):
-        logger.info(f"Creating board: {name}")
-
-        # Check if the board already exists
-        logger.info(f"Checking if board {name} already exists...")
-        self.cursor.execute('''
-            SELECT * FROM boards WHERE name = ?
-        ''', (name,))
-        board = self.cursor.fetchone()
-
-        if board:
-            logger.warning(f"Board {name} already exists.")
-            return False
-        logger.info(f"Board {name} does not exist.")
-
-        # Check if the owner exists
-        logger.info(f"Checking if owner {owner_id} exists...")
-        self.cursor.execute('''
-            SELECT * FROM users WHERE id = ?
-        ''', (owner_id,))
-        owner = self.cursor.fetchone()
-
-        if not owner:
-            logger.warning(f"Owner {owner_id} does not exist.")
-            return False
-        logger.info(f"Owner {owner_id} exists.")
-
-        # Create a new board
-        self.cursor.execute('''
-            INSERT INTO boards (name, owner_id, description)
-            VALUES (?, ?, ?)
-        ''', (name, owner_id, description))
-
-        self.connection.commit()
-        logger.info(f"Board {name} created.")
-        return True
-    
-
-    def get_board(self, name):
-        # Get board by name
-        logger.info(f"Getting board {name}...")
-        self.cursor.execute('''
-            SELECT * FROM boards WHERE name = ?
-        ''', (name,))
-        board = self.cursor.fetchone()
-
-        if board:
-            logger.info(f"Board {name} found.")
-            return board
-        logger.warning(f"Board {name} not found.")
-        return None
-    
-
-    def create_post(self, user_id, board_id, content, ref=None):
-        logger.info(f"Creating post for user {user_id} in board {board_id}...")
-
-        # Check if the user exists
-        logger.info(f"Checking if user {user_id} exists...")
-        self.cursor.execute('''
-            SELECT * FROM users WHERE id = ?
-        ''', (user_id,))
-        user = self.cursor.fetchone()
-
-        if not user:
-            logger.warning(f"User {user_id} does not exist.")
-            return False
-        logger.info(f"User {user_id} exists.")
-
-        # Check if the board exists
-        logger.info(f"Checking if board {board_id} exists...")
-        self.cursor.execute('''
-            SELECT * FROM boards WHERE id = ?
-        ''', (board_id,))
-        board = self.cursor.fetchone()
-
-        if not board:
-            logger.warning(f"Board {board_id} does not exist.")
-            return False
-        logger.info(f"Board {board_id} exists.")
-
-        # Check if the reference post exists
-        if ref is not None:
-            logger.info(f"Checking if reference post {ref} exists...")
-            self.cursor.execute('''
-                SELECT * FROM posts WHERE id = ?
-            ''', (ref,))
-            reference_post = self.cursor.fetchone()
-
-            if not reference_post:
-                logger.warning(f"Reference post {ref} does not exist.")
-                return False
-            logger.info(f"Reference post {ref} exists.")
-        else:
-            logger.info("No reference post provided.")
-            
-        # Create a new post
-        self.cursor.execute('''
-            INSERT INTO posts (user_id, board_id, content, refence)
-            VALUES (?, ?, ?, ?)
-        ''', (user_id, board_id, content, ref))
-        self.connection.commit()
-        logger.info(f"Post created for user {user_id} in board {board_id}.")
-        post_id = self.cursor.lastrowid
-        logger.info(f"Post ID: {post_id}")
-        return post_id
-    
-
-    def get_post(self, post_id):
-        # Get post by ID
-        logger.info(f"Getting post {post_id}...")
-        self.cursor.execute('''
-            SELECT * FROM posts WHERE id = ?
-        ''', (post_id,))
-        post = self.cursor.fetchone()
-
-        if post:
-            logger.info(f"Post {post_id} found.")
-            return post
-        logger.warning(f"Post {post_id} not found.")
-        return None
-
-
-    def get_post_references(self, post_id, limit=10, offset=0):
-        # Get references for a post
-        logger.info(f"Getting references for post {post_id}...")
-        self.cursor.execute('''
-            SELECT * FROM posts WHERE refence = ? LIMIT ? OFFSET ?
-        ''', (post_id, limit, offset))
-        references = self.cursor.fetchall()
-
-        if references:
-            logger.info(f"References found for post {post_id}.")
-            return references
-        logger.warning(f"No references found for post {post_id}.")
-        return None
-    
-
-    def get_posts(self, board_id, limit, offset):
-        if board_id:
-            logger.info(f"Getting posts for board {board_id}...")
-
-            # Check if the board exists
-            logger.info(f"Checking if board {board_id} exists...")
-            self.cursor.execute('''
-                SELECT * FROM boards WHERE id = ?
-            ''', (board_id,))
-            board = self.cursor.fetchone()
-
-            if not board:
-                logger.warning(f"Board {board_id} does not exist.")
-                return None
-            logger.info(f"Board {board_id} exists.")
-
-            # Get posts for the board
-            logger.info(f"Getting posts for board {board_id}...")
-            self.cursor.execute('''
-                SELECT * FROM posts WHERE board_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?
-            ''', (board_id, limit, offset))
-            posts = self.cursor.fetchall()
-
-            if posts:
-                logger.info(f"Posts found for board {board_id}.")
-                return posts
-            logger.warning(f"No posts found for board {board_id}.")
-            return None
-        
-        else:
-            # Get all posts
-            logger.info(f"Getting all posts...")
-            self.cursor.execute('''
-                SELECT * FROM posts ORDER BY created_at DESC LIMIT ? OFFSET ?
-            ''', (limit, offset))
-            posts = self.cursor.fetchall()
-
-            if posts:
-                logger.info(f"Posts found.")
-                return posts
-            logger.warning(f"No posts found.")
-            return None
-    
-
-    def get_latest_posts(self, limit):
-        logger.info(f"Getting latest posts...")
-
-        # Get latest posts
-        logger.info(f"Getting latest posts...")
-        self.cursor.execute('''
-            SELECT * FROM posts ORDER BY created_at DESC LIMIT ?
-        ''', (limit,))
-        posts = self.cursor.fetchall()
-
-        if posts:
-            logger.info(f"Latest posts found.")
-            return posts
-        logger.warning(f"No latest posts found.")
-        return None
-    
-
-    def get_boards(self, limit, offset):
-        logger.info(f"Listing boards with limit {limit} and offset {offset}...")
-
-        # Get boards with pagination
-        self.cursor.execute('''
-            SELECT * FROM boards ORDER BY created_at DESC LIMIT ? OFFSET ?
-        ''', (limit, offset))
-        boards = self.cursor.fetchall()
-
-        if boards:
-            logger.info(f"Boards found.")
-            return boards
-        logger.warning(f"No boards found.")
-        return None
-    
-
-    def post_to_dict(self, post):
-        # Convert post to dictionary
-        logger.info(f"Converting post to dictionary...")
-        data = {
-            'id': post[0],
-            'content': post[3],
-            'short_content': post[3][:40] + '...' if len(post[3]) > 40 else post[3],
-            'created_at': post[4],
-            'url': f"/post/{post[0]}",
-        }
-
-        # Get user information
-        logger.info(f"Getting user information for post {post[0]}...")
-        self.cursor.execute('''
-            SELECT * FROM users WHERE id = ?
-        ''', (post[1],))
-        user = self.cursor.fetchone()
-
-        if user:
-            data['user'] = {
-                'id': user[0],
-                'name': user[1],
-                'created_at': user[3]
-            }
-            logger.info(f"User information found for post {post[0]}.")
-        else:
-            logger.warning(f"User information not found for post {post[0]}.")
-            data['user'] = {
-                'id': None,
-                'name': None,
-                'created_at': None
-            }
-            
-        # Get board information
-        logger.info(f"Getting board information for post {post[0]}...")
-        self.cursor.execute('''
-            SELECT * FROM boards WHERE id = ?
-        ''', (post[2],))
-        board = self.cursor.fetchone()
-
-        if board:
-            data['board'] = {
-                'id': board[0],
-                'name': board[1],
-                'description': board[3],
-                'created_at': board[4]
-            }
-            logger.info(f"Board information found for post {post[0]}.")
-        else:
-            logger.warning(f"Board information not found for post {post[0]}.")
-            data['board'] = {
-                'id': None,
-                'name': None,
-                'description': None,
-                'created_at': None
-            }
-
-        # Get reference post information
-        if post[5] is not None:
-            logger.info(f"Getting reference post information for post {post[0]}...")
-            self.cursor.execute('''
-                SELECT * FROM posts WHERE id = ?
-            ''', (post[5],))
-            reference_post = self.cursor.fetchone()
-
-            if reference_post:
-                data['reference'] = {
-                    'id': reference_post[0],
-                    'content': reference_post[3],
-                    'short_content': reference_post[3][:20] + '...' if len(reference_post[3]) > 20 else reference_post[3],
-                    'created_at': reference_post[4]
-                }
-                logger.info(f"Reference post information found for post {post[0]}.")
+    def execute_query(self, query, params=None, fetch_type=FETCHALL):
+        try:
+            if params:
+                self.cursor.execute(query, params)
             else:
-                logger.warning(f"Reference post information not found for post {post[0]}.")
-                data['reference'] = {
-                    'id': None,
-                    'content': None,
-                    'created_at': None
-                }
-        else:
-            logger.info("No reference post.")
-            data['reference'] = None
+                self.cursor.execute(query)
+            self.connection.commit()
+            log.debug(f"Executed query: {query}")
+            if fetch_type == FETCHALL:
+                return self.fetchall()
+            elif fetch_type == FETCHONE:
+                return self.fetchone()
+            elif fetch_type is None:
+                log.debug("No fetch type specified, returning None")
+                return None
+            else:
+                log.warning("Invalid fetch type, returning None")
+                return None
+        except (sqlite3.Error, mysql.connector.Error) as e:
+            log.critical(f"Query execution error: {e}")
+            raise
 
-        # get post references
-        logger.info(f"Getting post references for post {post[0]}...")
-        self.cursor.execute('''
-            SELECT * FROM posts WHERE refence = ?
-        ''', (post[0],))
-        references = self.cursor.fetchall()
+    def fetchall(self):
+        try:
+            result = self.cursor.fetchall()
+            log.debug(f"Fetched all results")
+            return result
+        except (sqlite3.Error, mysql.connector.Error) as e:
+            log.error(f"Fetchall error: {e}")
+            raise
 
-        if references:
-            data['replies'] = []
-            for reference in references:
-                reference_data = {
-                    'id': reference[0],
-                    'content': reference[3],
-                    'short_content': reference[3][:20] + '...' if len(reference[3]) > 20 else reference[3],
-                    'created_at': reference[4]
-                }
-                data['replies'].append(reference_data)
-            logger.info(f"Post references found for post {post[0]}.")
-        else:
-            logger.warning(f"No post references found for post {post[0]}.")
-            data['replies'] = []
+    def fetchone(self):
+        try:
+            result = self.cursor.fetchone()
+            log.debug(f"Fetched one result")
+            return result
+        except (sqlite3.Error, mysql.connector.Error) as e:
+            log.critical(f"Fetchone error: {e}")
+            raise
 
-        logger.info(f"Post converted to dictionary.")
-        return data
+
+def first_time_run(db:Database):
+    log.info("First time run detected, initializing database")
+
+    # Create users table
+    log.info("Creating users table")
+    db.execute_query("""
+        CREATE TABLE users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT NOT NULL,
+            password TEXT NOT NULL,
+            about TEXT DEFAULT 'No description',
+            permissions TEXT DEFAULT 'user',
+            avatar MEDIUMBLOB,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            token TEXT,
+            avatar_type TEXT
+        )
+    """)
+
+    # Create posts table
+    log.info("Creating posts table")
+    db.execute_query("""
+        CREATE TABLE posts (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id INTEGER NOT NULL,
+            board_id INTEGER NOT NULL,
+            content TEXT NOT NULL,
+            reference INTREGER,
+            type TEXT DEFAULT 'post',
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE,
+            FOREIGN KEY (board_id) REFERENCES boards (id) ON DELETE CASCADE,
+            FOREIGN KEY (reference) REFERENCES posts (id) ON DELETE SET NULL
+        )
+    """)
+
+    # Create boards table
+    log.info("Creating boards table")
+    db.execute_query("""
+        CREATE TABLE boards (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            description TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            owner_id INTEGER NOT NULL,
+            FOREIGN KEY (owner_id) REFERENCES users (id)
+        )
+    """)
+
+    # Create attachments table
+    db.execute_query("""
+        CREATE TABLE attachments (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            post_id INTEGER NOT NULL,
+            file_data MEDIUMBLOB NOT NULL,
+            file_name TEXT NOT NULL,
+            file_type TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            FOREIGN KEY (post_id) REFERENCES posts (id) ON DELETE CASCADE
+        )
+    """)
+
+    # Create system user
+
+    if not env('SYSTEM_PASSWORD'):
+        log.warning("SYSTEM_PASSWORD is empty, generating random password")
+        password = os.urandom(16).hex()
+        log.info(f"Generated system user password: {password}")
+    else:
+        password = env('SYSTEM_PASSWORD')
     
+    log.info("Creating system user")
+    db.execute_query("""
+        INSERT INTO users (username, password, about, permissions)
+        VALUES (?, ?, ?, ?)
+    """, (
+        env('SYSTEM_USER', default='system'),
+        env('SYSTEM_PASSWORD', default=hashlib.sha256(password.encode()).hexdigest()),
+        env('SYSTEM_ABOUT', default='System User'),
+        env('SYSTEM_PERMISSIONS', default='admin')
+    ))
 
-    def create_session(self, username, password):
-        logger.info(f"Creating session for user {username}...")
+    # Create system boards
+    boards_names = env('SYSTEM_BOARDS', default='General,Random,System').split(',')
+    if "System" not in boards_names:
+        boards_names.append("System")
 
-        # Check if the user exists
-        logger.info(f"Checking if user {username} exists...")
-        self.cursor.execute('''
-            SELECT * FROM users WHERE username = ?
-        ''', (username,))
-        user = self.cursor.fetchone()
+    log.info(f"Creating system boards: {', '.join(boards_names)}")
+    for board_name in boards_names:
+        db.execute_query("""
+            INSERT INTO boards (name, description, owner_id)
+            VALUES (?, ?, ?)
+        """, (
+            board_name,
+            f"This is a automatically created board for {board_name}",
+            1
+        ))
 
-        if not user:
-            logger.warning(f"User {username} does not exist.")
-            return None
-        logger.info(f"User {username} exists.")
-
-        # Check if the password is correct
-        logger.info(f"Checking password for user {username}...")
-        if user[2] != password:
-            logger.warning(f"Incorrect password for user {username}.")
-            return None
-        logger.info(f"Password for user {username} is correct.")
-
-        # Create a new session and overwrite the old one if it exists
-        session = os.urandom(16).hex()
-        self.cursor.execute('''
-            UPDATE users SET session = ? WHERE username = ?
-        ''', (session, username))
-
-        self.connection.commit()
-        logger.info(f"Session created for user {username}.")
-        return session
-    
-
-    def get_session(self, session):
-        logger.info(f"Getting session {session}...")
-
-        # Get session information
-        self.cursor.execute('''
-            SELECT * FROM users WHERE session = ?
-        ''', (session,))
-        user = self.cursor.fetchone()
-
-        if user:
-            logger.info(f"Session {session} found.")
-            return user
-        logger.warning(f"Session {session} not found.")
-        return None
-    
-
-    def delete_session(self, session):
-        logger.info(f"Deleting session {session}...")
-
-        # Delete session
-        self.cursor.execute('''
-            UPDATE users SET session = NULL WHERE session = ?
-        ''', (session,))
-
-        self.connection.commit()
-        logger.info(f"Session {session} deleted.")
-        return True
-    
-
-    def user_to_dict(self, user):
-        # Convert user to dictionary
-        logger.info(f"Converting user to dictionary...")
-        data = {
-            'id': user[0],
-            'name': user[1],
-            'created_at': user[4]
-        }
-        logger.info(f"User converted to dictionary.")
-        return data
-    
-
-    def get_user_posts(self, user_id, limit=10, offset=0):
-        logger.info(f"Getting posts for user {user_id}...")
-
-        # Get posts for the user
-        self.cursor.execute('''
-            SELECT * FROM posts WHERE user_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?
-        ''', (user_id, limit, offset))
-        posts = self.cursor.fetchall()
-
-        if posts:
-            logger.info(f"Posts found for user {user_id}.")
-            return posts
-        logger.warning(f"No posts found for user {user_id}.")
-        return None
-    
-
-    def board_to_dict(self, board):
-        # Convert board to dictionary
-        logger.info(f"Converting board to dictionary...")
-        data = {
-            'id': board[0],
-            'name': board[1],
-            'description': board[3],
-            'created_at': board[4]
-        }
-        logger.info(f"Board converted to dictionary.")
-        return data
-    
-
-    def get_board_posts(self, board_id, limit=10, offset=0):
-        logger.info(f"Getting posts for board {board_id}...")
-
-        # Get posts for the board
-        self.cursor.execute('''
-            SELECT * FROM posts WHERE board_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?
-        ''', (board_id, limit, offset))
-        posts = self.cursor.fetchall()
-
-        if posts:
-            logger.info(f"Posts found for board {board_id}.")
-            return posts
-        logger.warning(f"No posts found for board {board_id}.")
-        return None
-    
-
-    def get_all_boards_for_post(self):
-        logger.info(f"Getting all boards...")
-
-        # Get all boards
-        self.cursor.execute('''
-            SELECT * FROM boards
-        ''')
-        boards = self.cursor.fetchall()
-
-        if boards:
-            logger.info(f"Boards found.")
-            # Convert boards to dictionary
-            boards = [{"id": board[0], "name": board[1]} for board in boards]
-            boards.sort(key=lambda x: x['name'])
-            return boards
-        logger.warning(f"No boards found.")
-        return None
-    
-    def delete_post(self, post_id):
-        logger.info(f"Deleting post {post_id}...")
-
-        # Delete post
-        self.cursor.execute('''
-            DELETE FROM posts WHERE id = ?
-        ''', (post_id,))
-
-        self.connection.commit()
-        logger.info(f"Post {post_id} deleted.")
-        return True
\ No newline at end of file
+    log.info("First time run completed")
\ No newline at end of file
diff --git a/src/html/board.html b/src/html/board.html
index 10d04a3..3d796bb 100644
--- a/src/html/board.html
+++ b/src/html/board.html
@@ -1,44 +1,42 @@
-{% extends "base.html" %}
+{% extends "templates/base.html" %}
 
-{% block content %}
-    <h1>{{ board.name }}</h1>
-    <h6>Created at: {{ board.created_at }}</h6>
+{% block head %}
+    <link rel="stylesheet" href="../static/css/form.css">
+{% endblock %}
+
+{% block main_content %}
+    <h1 class="board-name">/{{ board.name }}/</h1>
     <p>{{ board.description }}</p>
+    {% if board.owner_id == session.user_id %}
+        <h6><a href="/boards/delete/{{ board.id }}">Delete Board</a></h6>
+    {% endif %}
+    {% if session.user_id %}
+        <br>
+        <h3>Post to this board</h3>
+        <form action="/post" method="POST" enctype="multipart/form-data">
+            <input type="hidden" name="board_id" value="{{ board.id }}">
+            <textarea name="content" placeholder="Content" required></textarea>
+            <input type="file" name="attachments" multiple>
+            <button type="submit">Post</button>
+        </form>
+    {% endif %}
     <br>
-    <h1>Posts:</h1>
-    <ul class="posts">
-        {% for post in board.posts %}
+    <ul class="post-list">
+        {% for post in posts %}
             <li>
-                <h3>From {{ post.user.name }}</h3>
-                <h6>posted at {{ post.created_at }}</h6>
-                {% if post.reference %}
-                <h6><b>ref post:</b> <a href="/posts/{{ post.reference.id }}">{{ post.reference.short_content }}</a></h6>
-                {% endif %}
-                <p>{{ post.short_content }}</p>
-                <h6><a href="/posts/{{ post.id }}">View Post</a>
-                    {% if post.replies|length > 0 %}
-                     ({{ post.replies|length }} replies)
-                    {% endif %}
-                    {% if session.name == "SYSTEM" %}
-                     | <a href="/delete/post/{{ post.id }}">Delete</a>
-                    {% elif session.name == post.user.name %}
-                     | <a href="/delete/post/{{ post.id }}">Delete</a>
-                    {% endif %}
-                </h6>
+                {% include "templates/short_post.html" %}
             </li>
         {% endfor %}
-        {% if board.posts|length == 0 %}
-            <li>No posts found.</li>
-        {% endif %}
     </ul>
-    <div id="nav">
-        <h5>Page {{ page }}</h5>
-        {% if page > 1 %}
-        <h5><a href="/boards/{{ board.name }}?page={{ page - 1 }}">Previous Page</a></h5>
-        {% endif %}
-        
-        {% if board.posts|length == 10 %}
-        <h5><a href="/boards/{{ board.name }}?page={{ page + 1 }}">Next Page</a></h5>
-        {% endif %}
-    </div>
+    {% if total_pages > 0 %}
+        <div id="nav">
+            <h5>Page {{ page }} of {{ total_pages }}</h5>
+            {% if page > 1 %}
+                <h5><a href="/boards/{{ board.name }}?page={{ page - 1 }}">Previous Page</a></h5>
+            {% endif %}
+            {% if posts|length == 10 %}
+                <h5><a href="/boards/{{ board.name }}?page={{ page + 1 }}">Next Page</a></h5>
+            {% endif %}
+        </div>
+    {% endif %}
 {% endblock %}
\ No newline at end of file
diff --git a/src/html/boards.html b/src/html/boards.html
index 39a0e6e..31f6263 100644
--- a/src/html/boards.html
+++ b/src/html/boards.html
@@ -1,30 +1,30 @@
-{% extends "base.html" %}
+{% extends "templates/base.html" %}
 
-{% block content %}
+{% block head %}
+    <link rel="stylesheet" href="../static/css/boards.css">
+{% endblock %}
+
+{% block main_content %}
     <h1>Boards</h1>
-    <h5>Page {{ page }}</h5>
+    <p>Here are the boards available on this site. To create a new board, click <a href="/boards/new">here</a>.</p>
     <br>
-    <ul class="posts">
+    <ul class="board-list">
         {% for board in boards %}
             <li>
-                <h3>/{{ board.name }}/</h3>
-                <h6>created at {{ board.created_at }}</h6>
+                <h3><a class="board-name" href="/boards/{{ board.name }}">/{{ board.name }}/</a></h3>
                 <p>{{ board.description }}</p>
-                <h6><a href="/boards/{{ board.name }}">View Board</a></h6>
             </li>
         {% endfor %}
-        {% if boards|length == 0 %}
-        <li>No boards found.</li>
-        {% endif %}
     </ul>
-    <div id="nav">
-        <h5>Page {{ page }}</h5>
-        {% if page > 1 %}
-        <h5><a href="/boards?page={{ page - 1 }}">Previous Page</a></h5>
-        {% endif %}
-        
-        {% if boards|length == 10 %}
-        <h5><a href="/boards?page={{ page + 1 }}">Next Page</a></h5>
-        {% endif %}
-    </div>
+    {% if total_pages > 0 %}
+        <div id="nav">
+            <h5>Page {{ page }} of {{ total_pages }}</h5>
+            {% if page > 1 %}
+                <h5><a href="/boards?page={{ page - 1 }}">Previous Page</a></h5>
+            {% endif %}
+            {% if boards|length == 10 %}
+                <h5><a href="/boards?page={{ page + 1 }}">Next Page</a></h5>
+            {% endif %}
+        </div>
+    {% endif %}
 {% endblock %}
\ No newline at end of file
diff --git a/src/html/error.html b/src/html/error.html
new file mode 100644
index 0000000..97c84a2
--- /dev/null
+++ b/src/html/error.html
@@ -0,0 +1,9 @@
+{% extends "templates/base.html" %}
+
+{% block main_content %}
+    <h1>OOPSIE WOOPSIE!!</h1>
+    <h3>UwU you did a slight fucky wucky >w<</h3>
+    <br>
+    <h3>Thwe bwunder in qwestion :3</h3>
+    <p>{{error}}</p>
+{% endblock %}
\ No newline at end of file
diff --git a/src/html/index.html b/src/html/index.html
index 087d3e7..6cab558 100644
--- a/src/html/index.html
+++ b/src/html/index.html
@@ -1,33 +1,24 @@
-{% extends "base.html" %}
+{% extends "templates/base.html" %}
 
-{% block content %}
+{% block head %}
+    <link rel="stylesheet" href="../static/css/index.css">
+{% endblock %}
+
+{% block main_content %}
     <h1>Welcome to Prismic</h1>
-    <p>Prismic is a simple textboard</p>
+    <p>Prismic is a simple, fast, and secure way to share your thoughts with the world. Join us today and start sharing your ideas!</p>
     <br>
-    <h1>Latest Posts:</h1>
-    <ul class="posts">
-        {% for post in posts %}
-            <li>
-                <h3>From {{ post.user.name }} in /{{ post.board.name }}/</h3>
-                <h6>posted at {{ post.created_at }}</h6>
-                {% if post.reference %}
-                <h6><b>ref post:</b> <a href="/posts/{{ post.reference.id }}">{{ post.reference.short_content if post.reference.id is not none else '[NOT FOUND]' }}</a></h6>
-                {% endif %}
-                <p>{{ post.short_content }}</p>
-                <h6><a href="/posts/{{ post.id }}">View Post</a>
-                    {% if post.replies|length > 0 %}
-                     ({{ post.replies|length }} replies)
-                    {% endif %}
-                    {% if session.name == "SYSTEM" %}
-                     | <a href="/delete/post/{{ post.id }}">Delete</a>
-                    {% elif session.name == post.user.name %}
-                     | <a href="/delete/post/{{ post.id }}">Delete</a>
-                    {% endif %}
-                </h6>
-            </li>
-        {% endfor %}
-        {% if posts|length == 0 %}
-        <li>No posts found.</li>
-        {% endif %}
+    {% if session.name %}
+        <p>Hello <a class="user-{{session.perms}}" href="/users/{{session.name}}">{{session.name}}</a>! You are logged in.</p>
+    {% else %}
+        <p><a href="/login">Login</a> or <a href="/register">Register</a></p>
+    {% endif %}
+    <br>
+    <h3>Stats:</h3>
+    <ul class="stats">
+        <li>Total Posts: {{ total_posts }}</li>
+        <li>Total Boards: {{ total_boards }}</li>
+        <li>Total Users: {{ total_users }}</li>
+        <li>Total Attachments: {{ total_attachments }}</li>
     </ul>
 {% endblock %}
\ No newline at end of file
diff --git a/src/html/login.html b/src/html/login.html
index d7c7aaf..a859a1f 100644
--- a/src/html/login.html
+++ b/src/html/login.html
@@ -1,6 +1,10 @@
-{% extends "base.html" %}
+{% extends "templates/base.html" %}
 
-{% block content %}
+{% block head %}
+    <link rel="stylesheet" href="../static/css/form.css">
+{% endblock %}
+
+{% block main_content %}
     <h1>Login</h1>
     <p><a href="/register">Register</a> if you don't have an account.</p>
     <br>
diff --git a/src/html/new_board.html b/src/html/new_board.html
new file mode 100644
index 0000000..f8c968d
--- /dev/null
+++ b/src/html/new_board.html
@@ -0,0 +1,22 @@
+{% extends "templates/base.html" %}
+
+{% block head %}
+    <link rel="stylesheet" href="../static/css/form.css">
+{% endblock %}
+
+{% block main_content %}
+    <h1>New Board</h1>
+    <br>
+    <form method="POST" action="/boards/new">
+        <label for="board_name">Board Name:</label>
+        <input type="text" id="name" name="name" required>
+        <br>
+        <label for="board_description">Board Description:</label>
+        <input type="text" id="description" name="description" required>
+        <br>
+        <button type="submit">Create Board</button>
+    </form>
+    {% if error %}
+        <p style="color: red;">{{ error }}</p>
+    {% endif %}
+{% endblock %}
\ No newline at end of file
diff --git a/src/html/newpost.html b/src/html/newpost.html
deleted file mode 100644
index 1237dc3..0000000
--- a/src/html/newpost.html
+++ /dev/null
@@ -1,20 +0,0 @@
-{% extends "base.html" %}
-
-{% block content %}
-    <form method="POST" action="/post">
-        <label for="board">Board:</label>
-        <select id="board" name="board">
-            {% for board in boards %}
-                <option value="{{ board.id }}">{{ board.name }}</option>
-            {% endfor %}
-        </select>
-        <br>
-        <label for="content">Content:</label>
-        <textarea id="content" name="content" rows="4" cols="50" required></textarea>
-        <br>
-        <button type="submit">Post</button>
-    </form>
-    {% if error %}
-        <p style="color: red;">{{ error }}</p>
-    {% endif %}
-{% endblock %}
\ No newline at end of file
diff --git a/src/html/post.html b/src/html/post.html
index 3ff5ef6..fda3e64 100644
--- a/src/html/post.html
+++ b/src/html/post.html
@@ -1,61 +1,75 @@
-{% extends "base.html" %}
+{% extends "templates/base.html" %}
 
-{% block content %}
-    <h2>From {{ post.user.name }} in /{{ post.board.name }}/</h2>
-    <h6>posted at {{ post.created_at }}</h6>
-    {% if post.reference %}
-    <h6><b>ref post:</b> <a href="/posts/{{ post.reference.id }}">{{ post.reference.content }}</a></h6>
+{% block head %}
+    <link rel="stylesheet" href="../static/css/form.css">
+{% endblock %}
+
+{% block main_content %}
+    <h1><a href="/users/{{post.user.name}}" class="user-{{post.user.perms}}">{{post.user.name}}</a> posted in <a href="/boards/{{post.board.name}}" class="board-name">/{{post.board.name}}/</a></h1>
+    <h4>posted at <span class="time">{{post.created_at}}</span></h4>
+    {% if post.reference and post.reference.show %}
+        <h4>ref post: <a href="/posts/{{post.reference.id}}">{{post.reference.short_content}}</a></h4>
     {% endif %}
-    <p>{{ post.content }}</p>
-    {% if session.name == "SYSTEM" %}
-    <h6><a href="/delete/post/{{ post.id }}">Delete</a></h6>
-    {% elif session.name == post.user.name %}
-    <h6><a href="/delete/post/{{ post.id }}">Delete</a></h6>
+    {% if post.attachments %}
+        <h4>{{post.attachments|length}} attachments</h4>
+        <div class="attachments">
+            {% for attachment in post.attachments %}
+                {% if attachment.type == "image" %}
+                    <a href="{{attachment.url}}"><img src="{{attachment.url}}" alt="{{attachment.file_name}}" width="350px"></a>
+                {% elif attachment.type == "video" %}
+                    <video width="350px" controls>
+                        <source src="{{attachment.url}}" type="video/mp4">
+                        Your browser does not support the video tag.
+                    </video>
+                {% elif attachment.type == "audio" %}
+                    <audio controls>
+                        <source src="{{attachment.url}}" type="audio/mpeg">
+                        Your browser does not support the audio element.
+                    </audio>
+                {% else %}
+                    <a href="{{attachment.url}}">{{attachment.file_name}}</a>
+                {% endif %}
+            {% endfor %}
+        </div>
+    {% endif %}
+    <p>{{post.content}}</p>
+    <h6>
+        {% if session.name == "SYSTEM" %}
+            <a href="/delete/post/{{ post.id }}">Delete</a>
+        {% elif session.name == post.user.name %}
+            <a href="/delete/post/{{ post.id }}">Delete</a>
+        {% endif %}
+    </h6>
+    {% if session.user_id %}
+        <br>
+        <h3>Reply to this post</h3>
+        <form action="/post" method="POST" enctype="multipart/form-data">
+            <input type="hidden" name="board_id" value="{{ post.board.id }}">
+            <input type="hidden" name="reference" value="{{ post.id }}">
+            <input type="hidden" name="type" value="comment">
+            <textarea name="content" placeholder="Content" required></textarea>
+            <input type="file" name="attachments" multiple>
+            <button type="submit">Post</button>
+        </form>
     {% endif %}
     <br>
-
-    <h3>Replies:</h3>
-    
-    <ul class="posts">
-        {% for reply in post.replies %}
+    <h1>{{ post.replies }} Replies</h1>
+    <ul class="post-list">
+        {% for post in replies %}
             <li>
-                <h3>From {{ reply.user.name }} in /{{ reply.board.name }}/</h3>
-                <h6>posted at {{ reply.created_at }}</h6>
-                <p>{{ reply.short_content }}</p>
-                <h6><a href="/posts/{{ reply.id }}">View Reply</a>
-                    {% if session.name == "SYSTEM" %}
-                     | <a href="/delete/post/{{ reply.id }}">Delete</a>
-                    {% elif session.name == post.user.name %}
-                     | <a href="/delete/post/{{ reply.id }}">Delete</a>
-                    {% endif %}
-                </h6>
+                {% include "templates/post.html" %}
             </li>
         {% endfor %}
-        {% if post.replies|length == 0 %}
-        <li>No replies found.</li>
-        {% endif %}
     </ul>
-    <div id="nav">
-        <h5>Page {{ page }}</h5>
-        {% if page > 1 %}
-        <h5><a href="/posts/{{ post.id }}?page={{ page - 1 }}">Previous Page</a></h5>
-        {% endif %}
-        
-        {% if post.replies|length == 10 %}
-        <h5><a href="/posts/{{ post.id }}?page={{ page + 1 }}">Next Page</a></h5>
-        {% endif %}
-    </div>
-    <br>
-    <form method="POST" action="/post">
-        <input type="hidden" name="ref" value="{{ post.id }}">
-        <input type="hidden" name="board" value="{{ post.board.id }}">
-        <input type="hidden" name="redirect" value="/posts/{{ post.id }}">
-        <label for="content">Reply:</label>
-        <textarea id="content" name="content" rows="4" cols="50" required></textarea>
-        <br>
-        <button type="submit">Post</button>
-    </form>
-    {% if error %}
-        <p style="color: red;">{{ error }}</p>
+    {% if total_pages > 0 %}
+        <div id="nav">
+            <h5>Page {{ page }} of {{ total_pages }}</h5>
+            {% if page > 1 %}
+                <h5><a href="/posts/{{ post.id }}?page={{ page - 1 }}">Previous Page</a></h5>
+            {% endif %}
+            {% if replies|length == 10 %}
+                <h5><a href="/posts/{{ post.id }}?page={{ page + 1 }}">Next Page</a></h5>
+            {% endif %}
+        </div>
     {% endif %}
 {% endblock %}
\ No newline at end of file
diff --git a/src/html/posts.html b/src/html/posts.html
index 2cb362f..badfcec 100644
--- a/src/html/posts.html
+++ b/src/html/posts.html
@@ -1,42 +1,25 @@
-{% extends "base.html" %}
+{% extends "templates/base.html" %}
 
-{% block content %}
+{% block main_content %}
     <h1>Posts</h1>
-    <h5>Page {{ page }}</h5>
+    <p>Here are the latest posts from all boards.</p>
     <br>
-    <ul class="posts">
+    <ul class="post-list">
         {% for post in posts %}
             <li>
-                <h3>From {{ post.user.name }} in /{{ post.board.name }}/</h3>
-                <h6>posted at {{ post.created_at }}</h6>
-                {% if post.reference %}
-                <h6><b>ref post:</b> <a href="/posts/{{ post.reference.id }}">{{ post.reference.short_content }}</a></h6>
-                {% endif %}
-                <p>{{ post.short_content }}</p>
-                <h6><a href="/posts/{{ post.id }}">View post</a>
-                    {% if post.replies|length > 0 %}
-                     ({{ post.replies|length }} replies)
-                    {% endif %}
-                    {% if session.name == "SYSTEM" %}
-                     | <a href="/delete/post/{{ post.id }}">Delete</a>
-                    {% elif session.name == post.user.name %}
-                     | <a href="/delete/post/{{ post.id }}">Delete</a>
-                    {% endif %}
-                </h6>
+                {% include "templates/short_post.html" %}   
             </li>
         {% endfor %}
-        {% if posts|length == 0 %}
-        <li>No replies found.</li>
-        {% endif %}
     </ul>
-    <div id="nav">
-        <h5>Page {{ page }}</h5>
-        {% if page > 1 %}
-        <h5><a href="/posts?page={{ page - 1 }}">Previous Page</a></h5>
-        {% endif %}
-        
-        {% if posts|length == 10 %}
-        <h5><a href="/posts?page={{ page + 1 }}">Next Page</a></h5>
-        {% endif %}
-    </div>
+    {% if total_pages > 0 %}
+        <div id="nav">
+            <h5>Page {{ page }} of {{ total_pages }}</h5>
+            {% if page > 1 %}
+                <h5><a href="/posts?page={{ page - 1 }}">Previous Page</a></h5>
+            {% endif %}
+            {% if posts|length == 10 %}
+                <h5><a href="/posts?page={{ page + 1 }}">Next Page</a></h5>
+            {% endif %}
+        </div>
+    {% endif %}
 {% endblock %}
\ No newline at end of file
diff --git a/src/html/register.html b/src/html/register.html
index 936010c..9954889 100644
--- a/src/html/register.html
+++ b/src/html/register.html
@@ -1,6 +1,10 @@
-{% extends "base.html" %}
+{% extends "templates/base.html" %}
 
-{% block content %}
+{% block head %}
+    <link rel="stylesheet" href="../static/css/form.css">
+{% endblock %}
+
+{% block main_content %}
     <h1>Register</h1>
     <br>
     <form method="POST" action="/register">
diff --git a/src/html/settings.html b/src/html/settings.html
new file mode 100644
index 0000000..0b232aa
--- /dev/null
+++ b/src/html/settings.html
@@ -0,0 +1,52 @@
+{% extends "templates/base.html" %}
+
+{% block head %}
+    <link rel="stylesheet" href="../static/css/form.css">
+{% endblock %}
+
+{% block main_content %}
+    <h1>Settings</h1>
+    <br>
+    <form method="POST" action="/settings">
+        <input type="hidden" name="type" value="username">
+        <label for="username">Change username:</label>
+        <input type="text" id="username" name="username" value="{{ session.name }}" required>
+        <button type="submit">Change username</button>
+    </form>
+    <br>
+    <form method="POST" action="/settings">
+        <input type="hidden" name="type" value="password">
+        <label for="old_password">Old password:</label>
+        <input type="password" id="old_password" name="old_password" required>
+        <label for="new_password">New password:</label>
+        <input type="password" id="new_password" name="new_password" required>
+        <button type="submit">Change password</button>
+    </form>
+    <br>
+    <form method="POST" action="/settings">
+        <input type="hidden" name="type" value="about">
+        <label for="about">About me:</label>
+        <textarea id="about" name="about" required>{{ session.about }}</textarea>
+        <button type="submit">Change about me</button>
+    </form>
+    <br>
+    <form method="POST" action="/settings" enctype="multipart/form-data">
+        <input type="hidden" name="type" value="avatar">
+        <label for="avatar">Change avatar:</label>
+        <input type="file" id="avatar" name="avatar" accept="image/png, image/jpeg, image/jpg, image/gif" required>
+        <button type="submit">Change avatar</button>
+    </form>
+    <br>
+    <form method="POST" action="/settings">
+        <input type="hidden" name="type" value="delete">
+        <label for="delete_account">Delete account:</label>
+        <input type="password" id="delete_account" name="delete_account" placeholder="Enter your password to confirm" required>
+        <button type="submit">Delete account</button>
+    </form>
+    {% if error %}
+        <p style="color: red;">{{ error }}</p>
+    {% endif %}
+    {% if success %}
+        <p style="color: green;">{{ success }}</p>
+    {% endif %}
+{% endblock %}
\ No newline at end of file
diff --git a/src/html/base.html b/src/html/templates/base.html
similarity index 61%
rename from src/html/base.html
rename to src/html/templates/base.html
index 98bf18c..eb7c2db 100644
--- a/src/html/base.html
+++ b/src/html/templates/base.html
@@ -4,24 +4,24 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Prismic</title>
-    <link rel="stylesheet" href="../static/base.css">
+    <meta name="author" content="Alfie King">
+    <link rel="stylesheet" href="../../static/css/base.css">
+    {% block head %}{% endblock %}
 </head>
 <body>
     <header>
         <div id="title">
             <h1>Prismic</h1>
-            <h2>ver: 1.0</h2>
+            <h2>ver: 2.0</h2>
         </div>
         <nav>
             <ul>
                 <li><a href="/">Home</a></li>
                 <li><a href="/boards">Boards</a></li>
                 <li><a href="/posts">Posts</a></li>
-                {% if session.name %}
-                <li><a href="/post">Post</a></li>
-                {% endif %}
+                <li><a href="/users">Users</a></li>
                 <li>{% if session.name %}
-                    <a href="/user/{{ session.name }}">{{ session.name }}</a>
+                    <a class="user-{{session.perms}}" href="/users/{{ session.name }}">{{ session.name }}</a>
                 {% else %}
                     <a href="/login">Login</a>
                 {% endif %}</li>
@@ -30,10 +30,10 @@
         </nav>
     </header>
     <main>
-        {% block content %}{% endblock %}
+        {% block main_content %}{% endblock %}
     </main>
     <footer>
-        <p>Created by <a href="https://alfieking.dev">Alfie King</a>{% if session.name %} | <a href="/logout">Logout</a>{% endif %}</p>
+        <p>Created by <a href="https://alfieking.dev">Alfie King</a>{% if session.name %} | <a href="/settings">Settings</a> | <a href="/logout">Logout</a>{% endif %}</p>
     </footer>
 </body>
 </html>
\ No newline at end of file
diff --git a/src/html/templates/post.html b/src/html/templates/post.html
new file mode 100644
index 0000000..27919c3
--- /dev/null
+++ b/src/html/templates/post.html
@@ -0,0 +1,29 @@
+<div class="post">
+    <h3><a href="/users/{{post.user.name}}" class="user-{{post.user.perms}}">{{post.user.name}}</a> posted in <a href="/boards/{{post.board.name}}" class="board-name">/{{post.board.name}}/</a></h3>
+    <h6>posted at <span class="time">{{post.created_at}}</span></h6>
+    {% if post.reference and post.reference.show %}
+        <h6>ref post: <a href="/posts/{{post.reference.id}}">{{post.reference.short_content}}</a></h6>
+    {% endif %}
+    {% if post.attachments %}
+        <h6>{{post.attachments|length}} attachments</h6>
+        <div class="attachments">
+            {% for attachment in post.attachments %}
+                {% if attachment.type == "image" %}
+                    <a href="{{attachment.url}}"><img src="{{attachment.url}}" alt="{{attachment.file_name}}" width="100px"></a>
+                {% endif %}
+            {% endfor %}
+        </div>
+    {% endif %}
+    <p>{{post.short_content}}</p>
+    <h6>
+        <a href="/posts/{{ post.id }}">View Post</a>
+        {% if post.replies > 0 %}
+        ({{ post.replies }} replies)
+        {% endif %}
+        {% if session.name == "SYSTEM" %}
+        | <a href="/delete/post/{{ post.id }}">Delete</a>
+        {% elif session.name == post.user.name %}
+        | <a href="/delete/post/{{ post.id }}">Delete</a>
+        {% endif %}
+    </h6>
+</div>
\ No newline at end of file
diff --git a/src/html/templates/short_post.html b/src/html/templates/short_post.html
new file mode 100644
index 0000000..cd09d0e
--- /dev/null
+++ b/src/html/templates/short_post.html
@@ -0,0 +1,29 @@
+<div class="post">
+    <h3><a href="/users/{{post.user.name}}" class="user-{{post.user.perms}}">{{post.user.name}}</a> posted in <a href="/boards/{{post.board.name}}" class="board-name">/{{post.board.name}}/</a></h3>
+    <h6>posted at <span class="time">{{post.created_at}}</span></h6>
+    {% if post.reference and post.reference.show %}
+        <h6>ref post: <a href="/post/{{post.reference.url}}">{{post.reference.short_content}}</a></h6>
+    {% endif %}
+    {% if post.attachments %}
+        <h6>{{post.attachments|length}} attachments</h6>
+        <div class="attachments">
+            {% for attachment in post.attachments %}
+                {% if attachment.type == "image" %}
+                    <a href="{{attachment.url}}"><img src="{{attachment.url}}" alt="{{attachment.file_name}}" width="100px"></a>
+                {% endif %}
+            {% endfor %}
+        </div>
+    {% endif %}
+    <p>{{post.short_content}}</p>
+    <h6>
+        <a href="/posts/{{ post.id }}">View Post</a>
+        {% if post.replies > 0 %}
+        ({{ post.replies }} replies)
+        {% endif %}
+        {% if session.name == "SYSTEM" %}
+        | <a href="/delete/post/{{ post.id }}">Delete</a>
+        {% elif session.name == post.user.name %}
+        | <a href="/delete/post/{{ post.id }}">Delete</a>
+        {% endif %}
+    </h6>
+</div>
\ No newline at end of file
diff --git a/src/html/user.html b/src/html/user.html
index 24ea5f4..63f4f6e 100644
--- a/src/html/user.html
+++ b/src/html/user.html
@@ -1,43 +1,40 @@
-{% extends "base.html" %}
+{% extends "templates/base.html" %}
 
-{% block content %}
-    <h1>{{ user.name }}</h1>
-    <h6>Joined at: {{ user.created_at }}</h6>
+{% block head %}
+    <link rel="stylesheet" href="../static/css/user.css">
+{% endblock %}
+
+{% block main_content %}
+    <div class="user">
+        {% if user.avatar_url %}
+        <img src="{{user.avatar_url}}" alt="Avatar">
+        {% else %}
+            <img src="/static/content/default_avatar.png" alt="Default Avatar">
+        {% endif %}
+        <div class="info">
+            <h1 class="user-{{user.perms}}">{{user.name}}</h1>
+            <h4>Joined at <span class="time">{{user.created_at}}</span></h4>
+        </div>
+    </div>
+    <p>{{user.about}}</p>
     <br>
-    <h1>Posts:</h1>
-    <ul class="posts">
-        {% for post in user.posts %}
+    <h2><span class="user-{{user.perms}}">{{ user.name }}'s</span> Posts</h2>
+    <ul class="post-list">
+        {% for post in posts %}
             <li>
-                <h3>From {{ post.user.name }} in /{{ post.board.name }}/</h3>
-                <h6>posted at {{ post.created_at }}</h6>
-                {% if post.reference %}
-                <h6><b>ref post:</b> <a href="/posts/{{ post.reference.id }}">{{ post.reference.content }}</a></h6>
-                {% endif %}
-                <p>{{ post.content }}</p>
-                <h6><a href="/posts/{{ post.id }}">View Post</a>
-                    {% if post.replies|length > 0 %}
-                    ({{ post.replies|length }} replies)
-                    {% endif %}
-                    {% if session.name == "SYSTEM" %}
-                     | <a href="/delete/post/{{ post.id }}">Delete</a>
-                    {% elif session.name == post.user.name %}
-                     | <a href="/delete/post/{{ post.id }}">Delete</a>
-                    {% endif %}
-                </h6>
+                {% include "templates/short_post.html" %}   
             </li>
         {% endfor %}
-        {% if user.posts|length == 0 %}
-            <li>No posts found.</li>
-        {% endif %}
     </ul>
-    <div id="nav">
-        <h5>Page {{ page }}</h5>
-        {% if page > 1 %}
-        <h5><a href="/user/{{ user.name }}?page={{ page - 1 }}">Previous Page</a></h5>
-        {% endif %}
-        
-        {% if user.posts|length == 10 %}
-        <h5><a href="/user/{{ user.name }}?page={{ page + 1 }}">Next Page</a></h5>
-        {% endif %}
-    </div>
+    {% if total_pages > 0 %}
+        <div id="nav">
+            <h5>Page {{ page }} of {{ total_pages }}</h5>
+            {% if page > 1 %}
+                <h5><a href="/users/{{user.d}}?page={{ page - 1 }}">Previous Page</a></h5>
+            {% endif %}
+            {% if posts|length == 10 %}
+                <h5><a href="/users/{{user.id}}?page={{ page + 1 }}">Next Page</a></h5>
+            {% endif %}
+        </div>
+    {% endif %}
 {% endblock %}
\ No newline at end of file
diff --git a/src/html/users.html b/src/html/users.html
new file mode 100644
index 0000000..e088994
--- /dev/null
+++ b/src/html/users.html
@@ -0,0 +1,39 @@
+{% extends "templates/base.html" %}
+
+{% block head %}
+    <link rel="stylesheet" href="../static/css/user.css">
+{% endblock %}
+
+{% block main_content %}
+    <h1>Users</h1>
+    <p>Here are the boards users on this site.</p>
+    <br>
+    <ul class="board-list">
+        {% for user in users %}
+            <li>
+                <a href="/users/{{user.name}}" class="user">
+                    {% if user.avatar_url %}
+                    <img src="{{user.avatar_url}}" alt="Avatar">
+                    {% else %}
+                        <img src="/static/content/default_avatar.png" alt="Default Avatar">
+                    {% endif %}
+                    <div class="info">
+                        <h1 class="user-{{user.perms}}">{{user.name}}</h1>
+                        <h4>Joined at <span class="time">{{user.created_at}}</span></h4>
+                    </div>
+                </a>
+            </li>
+        {% endfor %}
+    </ul>
+    {% if total_pages > 0 %}
+        <div id="nav">
+            <h5>Page {{ page }} of {{ total_pages }}</h5>
+            {% if page > 1 %}
+                <h5><a href="/users?page={{ page - 1 }}">Previous Page</a></h5>
+            {% endif %}
+            {% if boards|length == 10 %}
+                <h5><a href="/users?page={{ page + 1 }}">Next Page</a></h5>
+            {% endif %}
+        </div>
+    {% endif %}
+{% endblock %}
\ No newline at end of file
diff --git a/src/main.py b/src/main.py
index 583dead..6ad7fa7 100644
--- a/src/main.py
+++ b/src/main.py
@@ -1,375 +1,697 @@
-from flask import Flask, request, render_template, session, redirect
-import database, logging, os, hashlib
+from flask import Flask, render_template, request, send_file, session, redirect
+from database import FETCHALL, FETCHONE
 from flask_session import Session
+import logging, database, utils
+from os import getenv as env
+from os import urandom
+from io import BytesIO
+from os import path
+import hashlib
 
 
-# Global variables
-SYSTEMUID = None
-SYSTEMBID = None
-ALLOWED_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%£^&()-_=+[]{};:'\",.<>?/\\|`~ \n"
+# if .env file exists, load it
+if path.exists('.env'):
+    from dotenv import load_dotenv
+    load_dotenv()
 
-# Configure logging
+# Create console handler with a specific format
 console_log = logging.StreamHandler()
 console_log.setFormatter(logging.Formatter("\033[1;32m%(asctime)s\033[0m - \033[1;34m%(levelname)s\033[0m - \033[1;31m%(name)s\033[0m - %(message)s"))
-logger = logging.getLogger()
-logger.addHandler(console_log)
-logger.setLevel(logging.INFO)
+console_log.setLevel(logging.INFO)
+
+# Create file handler with a specific format
+file_log = logging.FileHandler(env('LOG_FILE', default='app.log'))
+file_log.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(name)s - %(message)s"))
+file_log.setLevel(logging.DEBUG)
+
+# Add handlers to the logger
+log = logging.getLogger()
+log.setLevel(logging.DEBUG)
+log.addHandler(console_log)
+log.addHandler(file_log)
+log.info("Logging initialized")
 
 
-# Helper functions
-def sanitize_input(input_string):
-    logger.info("Sanitizing input...")
-    # Sanitize input to allow only certain characters
-    if not isinstance(input_string, str):
-        logger.error("Input is not a string.")
-        return None
-    sanitized = ''.join(c for c in input_string if c in ALLOWED_CHARS)
-    logger.info("Sanitized input")
-    return sanitized
-
-
-def hash_password(password):
-    logger.info("Hashing password...")
-    # Hash the password using SHA-256
-    if not isinstance(password, str):
-        logger.error("Password is not a string.")
-        return None
-    hashed = hashlib.sha256(password.encode()).hexdigest()
-    logger.info("Hashed password")
-    return hashed
-
-
-# Initialize Flask app
-logger.info("Initializing Flask app...")
-app = Flask(__name__, template_folder=os.getenv('TEMPLATE_FOLDER', 'html'), static_folder=os.getenv('STATIC_FOLDER', 'static'))
+# Initialize Flask
+app = Flask(
+    __name__,
+    template_folder=env('TEMPLATE_FOLDER', default='html'),
+    static_folder=env('STATIC_FOLDER', default='static'),
+)
 app.config["SESSION_PERMANENT"] = True
 app.config["SESSION_TYPE"] = "filesystem"
 Session(app)
-logger.info("Flask app initialized.")
+log.info("Flask initialized")
 
 
-# Initialize database
-logger.info("Initializing database...")
-db = database.Database(os.getenv('DB_LOCATION', 'app.db'))
-
-if db.get_user('SYSTEM') is None:
-    logger.info("Running first time setup...")
-
-    logger.info("Creating SYSTEM user...")
-    password = os.getenv('SYSTEM_PASSWORD', None)
-    if password is None:
-        password = os.urandom(16).hex()
-    logger.info("Generated password for SYSTEM user: %s", password)
-    db.create_user('SYSTEM', hash_password(password))
-    SYSTEMUID = db.get_user('SYSTEM')[0]
-    logger.info("SYSTEM user created with UID: %s", SYSTEMUID)
-
-    logger.info("Creating SYSTEM board...")
-    db.create_board('System', 'System messages', SYSTEMUID)
-    db.create_board('General', 'General discussion', SYSTEMUID)
-    db.create_board('Linux', 'Linux discussion', SYSTEMUID)
-    db.create_board('Random', 'Random discussion', SYSTEMUID)
-    db.create_board('Tech', 'Tech discussion', SYSTEMUID)
-    db.create_board('Games', 'Games discussion', SYSTEMUID)
-    SYSTEMBID = db.get_board('System')[0]
-    logger.info("SYSTEM board created.")
-
-    logger.info("Creating First time setup post...")
-    db.create_post(SYSTEMBID, SYSTEMUID, 'Welcome!')
-    logger.info("First time setup post created.")
-
+# Initialize Database
+db = database.Database()
+# Check if DB_TYPE is set to mysql else default to sqlite
+if env('DB_TYPE') == 'mysql': 
+    db.connect_mysql()
 else:
-    SYSTEMUID = db.get_user('SYSTEM')[0]
-    SYSTEMBID = db.get_board('System')[0]
-    logger.info("SYSTEM user and board already exist.")
-    logger.info("SYSTEM user UID: %s", SYSTEMUID)
-    logger.info("SYSTEM board BID: %s", SYSTEMBID)
+    db.connect_sqlite(env('DB_PATH', default='database.db'))
 
-logger.info("Database initialized.")
+# check for first time run (if users table exists with any user)
+try: 
+    db.execute_query("SELECT * FROM users", fetch_type=FETCHONE)
+except:
+    log.info("First time run detected, initializing database")
+    database.first_time_run(db)
+
+
+# Configure utils
+log.info("Configuring utils")
+conv = utils.data_converter(db)
 
 
 # Define routes
 @app.route('/')
 def index():
-    logger.info("Rendering index page...")
-    latest_posts = db.get_latest_posts(5)
-    return render_template('index.html', posts=[db.post_to_dict(post) for post in latest_posts])
+    log.debug("Rendering index page")
+    # Get the total number of users, boards, and posts
+    total_users = db.execute_query("SELECT COUNT(*) FROM users", fetch_type=FETCHONE)[0]
+    total_boards = db.execute_query("SELECT COUNT(*) FROM boards", fetch_type=FETCHONE)[0]
+    total_posts = db.execute_query("SELECT COUNT(*) FROM posts", fetch_type=FETCHONE)[0]
+    total_attachments = db.execute_query("SELECT COUNT(*) FROM attachments", fetch_type=FETCHONE)[0]
+    log.debug(f"Total users: {total_users}, Total boards: {total_boards}, Total posts: {total_posts}, Total attachments: {total_attachments}")
 
-
-@app.route('/posts/<int:post_id>')
-def post(post_id):
-    logger.info("Rendering post page for post ID: %s", post_id)
-    post = db.get_post(post_id)
-    if post is None:
-        logger.error("Post not found: %s", post_id)
-        return "Post not found", 404
-    
-    post = db.post_to_dict(post)
-    page = request.args.get('page', 1, type=int)
-
-    logger.info("Post found: %s", post_id)
-    replies = db.get_post_references(post_id, 10, 10 * (page - 1))
-    if replies is None:
-        logger.error("No replies found for post ID: %s", post_id)
-        post['replies'] = []
-    else:
-        logger.info("Found %s replies for post ID: %s", len(replies), post_id)
-        post['replies'] = [db.post_to_dict(reply) for reply in replies]
-        post['replies'].sort(key=lambda x: x['created_at'], reverse=True)
-
-    return render_template('post.html', post=post, page=page)
-
-
-@app.route('/login', methods=['GET', 'POST'])
-def login():
-    logger.info("Rendering login page...")
-    if request.method == 'POST':
-        username = request.form['username']
-        password = request.form['password']
-        username = sanitize_input(username)
-        password = sanitize_input(password)
-        token = db.create_session(username, hash_password(password))
-        if token:
-            logger.info("User %s logged in successfully.", username)
-            session['name'] = username
-            session['id'] = db.get_user(username)[0]
-            session['session'] = token
-            return redirect('/')
-        else:
-            logger.error("Invalid login attempt for user: %s", username)
-            return render_template('login.html', error="Invalid username or password.")
-        
-    return render_template('login.html')
-
-
-@app.route('/user/<string:username>')
-def user(username):
-    logger.info("Rendering user page for user: %s", username)
-    username = sanitize_input(username)
-    user = db.get_user(username)
-    if user is None:
-        logger.error("User not found: %s", username)
-        return "User not found", 404
-    
-    user = db.user_to_dict(user)
-    page = request.args.get('page', 1, type=int)
-
-    posts = db.get_user_posts(user['id'], 10, 10 * (page - 1))
-    if posts is None:
-        logger.error("No posts found for user: %s", username)
-        user['posts'] = []
-    else:
-        logger.info("Found %s posts for user: %s", len(posts), username)
-        user['posts'] = [db.post_to_dict(post) for post in posts]
-
-    return render_template('user.html', user=user, page=page)
-
-
-@app.route('/logout')
-def logout():
-    logger.info("Logging out user: %s", session.get('name'))
-    session.clear()
-    return redirect('/')
-
-
-@app.route('/posts')
-def posts():
-    logger.info("Rendering posts page...")
-    page = request.args.get('page', 1, type=int)
-    posts = db.get_posts(None, 10, 10 * (page - 1))
-    if posts is None:
-        logger.error("No posts found.")
-        return "No posts found", 404
-    
-    logger.info("Found %s posts.", len(posts))
-    return render_template('posts.html', posts=[db.post_to_dict(post) for post in posts], page=page)
+    return render_template(
+        'index.html', 
+        total_users=total_users,
+        total_boards=total_boards,
+        total_posts=total_posts,
+        total_attachments=total_attachments,
+    )
 
 
 @app.route('/boards')
 def boards():
-    logger.info("Rendering boards page...")
-
+    log.debug("Rendering boards page")
+    # Get the list of boards from the database
     page = request.args.get('page', 1, type=int)
-    boards = db.get_boards(10, 10 * (page - 1))
+    boards = db.execute_query("SELECT * FROM boards ORDER BY id LIMIT ? OFFSET ?", (10, (page - 1) * 10), fetch_type=FETCHALL)
+    boards = [conv.board_to_dict(board) for board in boards]
+    total_boards = db.execute_query("SELECT COUNT(*) FROM boards", fetch_type=FETCHONE)[0]
+    total_pages = (total_boards + 9) // 10
 
-    if boards is None:
-        logger.error("No boards found.")
-        return "No boards found", 404
-
-    logger.info("Found %s boards.", len(boards))
-    return render_template('boards.html', boards=[db.board_to_dict(board) for board in boards], page=page)
+    # Render the boards page with pagination
+    log.debug(f"Total boards: {total_boards}, Total pages: {total_pages}")
+    return render_template('boards.html', boards=boards, page=page, total_pages=total_pages)
 
 
-@app.route('/boards/<string:board>')
-def board(board):
-    logger.info("Rendering board page for board: %s", board)
-    board = sanitize_input(board)
-    board = db.get_board(board)
-    if board is None:
-        logger.error("Board not found: %s", board)
-        return "Board not found", 404
-    board_id = board[0]
+@app.route('/boards/<string:board_name>')
+def board(board_name):
+    log.debug(f"Validating board name")
+    # Validate the board name
+    if not utils.validate_board_name(board_name):
+        log.error(f"Invalid board name: {board_name}")
+        return "Invalid board name", 400
     
-    board = db.board_to_dict(board)
+    log.debug(f"Rendering board page for {board_name}")
+    # Get the board from the database
+    board = db.execute_query("SELECT * FROM boards WHERE name = ?", (board_name,), fetch_type=FETCHONE)
+    if not board:
+        log.error(f"Board {board_name} not found")
+        return "Board not found", 404
+
+    # Get the posts for the board
     page = request.args.get('page', 1, type=int)
+    posts = db.execute_query(
+        "SELECT * FROM posts WHERE board_id = ? AND type = ? ORDER BY created_at DESC LIMIT ? OFFSET ?",
+        (board[0], 'post', 10, (page - 1) * 10),
+        fetch_type=FETCHALL
+    ) 
+    total_posts = db.execute_query("SELECT COUNT(*) FROM posts WHERE board_id = ?", (board[0],), fetch_type=FETCHONE)[0]
+    total_pages = (total_posts + 9) // 10
+    posts = [conv.post_to_dict(post) for post in posts]
 
-    posts = db.get_board_posts(board_id, 10, 10 * (page - 1))
-    if posts is None:
-        logger.error("No posts found for board ID: %s", board_id)
-        board['posts'] = []
-    else:
-        logger.info("Found %s posts for board ID: %s", len(posts), board_id)
-        board['posts'] = [db.post_to_dict(post) for post in posts]
-
-    return render_template('board.html', board=board, page=page)
+    log.debug(f"Total posts: {total_posts}, Total pages: {total_pages}")
+    return render_template('board.html', board=conv.board_to_dict(board), posts=posts, page=page, total_pages=total_pages)
 
 
-@app.route('/post', methods=['POST', 'GET'])
-def post_create():
-    logger.info("Rendering post creation page...")
-    if request.method == 'POST':
-        content = request.form['content']
-        board_id = request.form['board']
-        ref = request.form.get('ref', None)
-        token = session.get('session')
+@app.route('/posts/<int:post_id>')
+def post(post_id):
+    log.debug(f"Rendering post page for post ID {post_id}")
+    # Get the post from the database
+    post = db.execute_query("SELECT * FROM posts WHERE id = ?", (post_id,), fetch_type=FETCHONE)
+    if not post:
+        log.error(f"Post {post_id} not found")
+        return "Post not found", 404
 
-        # sanitize input
-        content = sanitize_input(content)
-        try:
-            board_id = int(board_id)
-        except ValueError:
-            logger.error("Invalid board ID: %s", board_id)
-            return render_template('newpost.html', error="Invalid board ID.")
-        if not content:
-            logger.error("Post content is empty.")
-            return render_template('newpost.html', error="Post content cannot be empty.")
-        if not board_id:
-            logger.error("Board ID is empty.")
-            return render_template('newpost.html', error="Board ID cannot be empty.")
-        if not token:
-            logger.error("Session token is missing.")
-            return render_template('newpost.html', error="Session expired. Please log in again.")
-        if ref:
-            try:
-                ref = int(ref)
-            except ValueError:
-                logger.error("Invalid reference post ID: %s", ref)
-                return render_template('newpost.html', error="Invalid reference post ID.")
-        if len(content) > 10000:
-            logger.error("Post content exceeds maximum length.")
-            return render_template('newpost.html', error="Post content exceeds maximum length.")
+    # Get the comments for the post
+    page = request.args.get('page', 1, type=int)
+    comments = db.execute_query("SELECT * FROM posts WHERE reference = ? ORDER BY created_at DESC LIMIT ? OFFSET ?", (post_id, 10, (page - 1) * 10), fetch_type=FETCHALL)
+    total_comments = db.execute_query("SELECT COUNT(*) FROM posts WHERE reference = ?", (post_id,), fetch_type=FETCHONE)[0]
+    total_pages = (total_comments + 9) // 10
+    comments = [conv.post_to_dict(comment, False) for comment in comments]
 
-        user = db.get_session(token)
-        if user is None:
-            logger.error("Session not found or expired.")
-            return render_template('newpost.html', error="Session expired. Please log in again.")
-        user_id = user[0]
-
-        if board_id == SYSTEMBID and user_id != SYSTEMUID:
-            logger.error("User %s is not allowed to post in SYSTEM board.", user_id)
-            return render_template('newpost.html', error="You are not allowed to post in this board.")
-
-        if ref:
-            ref = db.get_post(ref)
-            if ref is None:
-                logger.error("Reference post not found: %s", ref)
-                return render_template('newpost.html', error="Reference post not found.")
-            ref = ref[0]
-
-        logger.info("Creating post in board ID: %s", board_id)
-        status = db.create_post(user_id, board_id, content, ref)
-
-        if type(status) is not int:
-            logger.error("Post creation failed.")
-            return "Post creation failed", 500
-        
-        logger.info("Post created successfully.")
-        if request.form.get('redirect'):
-            return redirect(request.form.get('redirect'))
-        return redirect('/posts/' + str(status))
-    return render_template('newpost.html', boards=db.get_all_boards_for_post())
+    return render_template('post.html', post=conv.post_to_dict(post), replies=comments, page=page, total_pages=total_pages)
 
 
-@app.route('/register', methods=['GET', 'POST'])
+@app.route('/posts')
+def posts():
+    log.debug("Rendering posts page")
+    # Get the list of posts from the database
+    page = request.args.get('page', 1, type=int)
+    posts = db.execute_query("SELECT * FROM posts WHERE type = ? ORDER BY created_at DESC LIMIT ? OFFSET ?", ('post', 10, (page - 1) * 10), fetch_type=FETCHALL)
+    total_posts = db.execute_query("SELECT COUNT(*) FROM posts WHERE type = ?", ('post',), fetch_type=FETCHONE)[0]
+    total_pages = (total_posts + 9) // 10
+    posts = [conv.post_to_dict(post) for post in posts]
+
+    log.debug(f"Total posts: {total_posts}, Total pages: {total_pages}")
+    return render_template('posts.html', posts=posts, page=page, total_pages=total_pages)
+
+
+@app.route('/attachment/<int:attachment_id>')
+def attachment(attachment_id):
+    log.debug(f"Rendering attachment page for attachment ID {attachment_id}")
+    # Get the attachment from the database
+    attachment = db.execute_query("SELECT * FROM attachments WHERE id = ?", (attachment_id,), fetch_type=FETCHONE)
+    if not attachment:
+        log.error(f"Attachment {attachment_id} not found")
+        return "Attachment not found", 404
+
+    # Render the attachment page
+    log.debug(f"Attachment found: {attachment}")
+    file = BytesIO(attachment[2])
+    return send_file(
+        file,
+        mimetype=attachment[4],
+        as_attachment=False,
+        download_name=attachment[3]
+    )
+
+
+@app.route('/users')
+def users():
+    log.debug("Rendering users page")
+    # Get the list of users from the database
+    page = request.args.get('page', 1, type=int)
+    users = db.execute_query("SELECT * FROM users ORDER BY id LIMIT ? OFFSET ?", (10, (page - 1) * 10), fetch_type=FETCHALL)
+    total_users = db.execute_query("SELECT COUNT(*) FROM users", fetch_type=FETCHONE)[0]
+    total_pages = (total_users + 9) // 10
+    users = [conv.user_to_dict(user) for user in users]
+
+    log.debug(f"Total users: {total_users}, Total pages: {total_pages}")
+    return render_template('users.html', users=users, page=page, total_pages=total_pages)
+
+
+@app.route('/users/<string:user>')
+def user(user):
+    log.debug(f"Validating user name")
+    # Validate the user name
+    if not utils.validate_username(user):
+        log.error(f"Invalid user name: {user}")
+        return "Invalid user name", 400
+    
+    log.debug(f"Rendering user page for {user}")
+    # Get the user from the database
+    user = db.execute_query("SELECT * FROM users WHERE username = ?", (user,), fetch_type=FETCHONE)
+    if not user:
+        log.error(f"User {user} not found")
+        return "User not found", 404
+
+    # Get the posts for the user
+    page = request.args.get('page', 1, type=int)
+    posts = db.execute_query("SELECT * FROM posts WHERE user_id = ? AND type = ? ORDER BY created_at DESC LIMIT ? OFFSET ?", (user[0], 'post', 10, (page - 1) * 10), fetch_type=FETCHALL)
+    total_posts = db.execute_query("SELECT COUNT(*) FROM posts WHERE user_id = ? AND type = ?", (user[0], 'post'), fetch_type=FETCHONE)[0]
+    total_pages = (total_posts + 9) // 10
+    posts = [conv.post_to_dict(post) for post in posts]
+
+    log.debug(f"Total posts: {total_posts}, Total pages: {total_pages}")
+    return render_template('user.html', user=conv.user_to_dict(user), posts=posts, page=page, total_pages=total_pages)
+
+
+@app.route('/login', methods=['GET'])
+def login():
+    log.debug("Rendering login page")
+    # Render the login page
+    return render_template('login.html')
+
+
+@app.route('/login', methods=['POST'])
+def login_post():
+    log.debug("Processing login form")
+    # Process the login form
+    username = request.form.get('username')
+    if not username:
+        log.error("No username provided")
+        return render_template('login.html', error="No username provided")
+    password = request.form.get('password')
+    if not password:
+        log.error("No password provided")
+        return render_template('login.html', error="No password provided")
+
+    # Hash the password
+    try:
+        password = password.encode()
+    except AttributeError:
+        log.error("Password encoding failed")
+        return render_template('login.html', error="Password encoding failed")
+    password = hashlib.sha256(password).hexdigest()
+    log.debug(f"Hashed password: {password}")
+
+    # validate the username and password
+    if not utils.validate_username(username):
+        log.error("Invalid username")
+        return render_template('login.html', error="Invalid username")
+
+    # Validate the user
+    user = db.execute_query("SELECT * FROM users WHERE username = ? AND password = ?", (username, password), fetch_type=FETCHONE)
+    if not user:
+        log.error("Invalid username or password")
+        return render_template('login.html', error="Invalid username or password")
+
+    # make token
+    token = urandom(16).hex()
+    db.execute_query("UPDATE users SET token = ? WHERE id = ?", (token, user[0]))
+    log.debug(f"Token generated for user {username}")
+
+    # Log in the user
+    session['user_id'] = user[0]
+    session['name'] = user[1]
+    session['perms'] = user[4]
+    session['token'] = token
+    log.info(f"User {username} logged in")
+
+    return redirect('/')
+
+
+@app.route('/register', methods=['GET'])
 def register():
-    logger.info("Rendering registration page...")
-    if request.method == 'POST':
-        username = request.form['username']
-        password = request.form['password']
-        username = sanitize_input(username)
-        password = sanitize_input(password)
-
-        if not username or not password:
-            logger.error("Username or password is empty.")
-            return render_template('register.html', error="Username and password cannot be empty.")
-        
-        if len(username) > 20:
-            logger.error("Username length is invalid.")
-            return render_template('register.html', error="Username must be less than 20 characters.")
-        
-        if len(password) < 6 or len(password) > 200:
-            logger.error("Password length is invalid.")
-            return render_template('register.html', error="Password must be between 6 and 200 characters.")
-
-        if db.get_user(username):
-            logger.error("Username already exists: %s", username)
-            return render_template('register.html', error="Username already exists.")
-
-        hashed_password = hash_password(password)
-        db.create_user(username, hashed_password)
-        logger.info("User %s registered successfully.", username)
-        db.create_post(SYSTEMUID, SYSTEMUID, f"New user \"{username}\" registered.")
-        # Create a session for the new user
-        token = db.create_session(username, hashed_password)
-        if token:
-            session['name'] = username
-            session['id'] = db.get_user(username)[0]
-            session['session'] = token
-            logger.info("User %s logged in after registration.", username)
-            return redirect('/')
-        else:
-            logger.error("Session creation failed for user: %s", username)
-            return render_template('register.html', error="Session creation failed.")
-        
-    logger.info("GET request for registration page.")
-    if session.get('name'):
-        logger.info("User %s is already logged in.", session['name'])
-        return redirect('/')
-    logger.info("Rendering registration form.")
-
+    log.debug("Rendering register page")
+    # Render the register page
     return render_template('register.html')
 
 
+@app.route('/register', methods=['POST'])
+def register_post():
+    log.debug("Processing register form")
+    # Process the register form
+    username = request.form.get('username')
+    if not username:
+        log.error("No username provided")
+        return render_template('login.html', error="No username provided")
+    password = request.form.get('password')
+    if not password:
+        log.error("No password provided")
+        return render_template('login.html', error="No password provided")
+
+    # Hash the password
+    try:
+        password = password.encode()
+    except AttributeError:
+        log.error("Password encoding failed")
+        return render_template('register.html', error="Password encoding failed")
+    password = hashlib.sha256(password).hexdigest()
+    log.debug(f"Hashed password: {password}")
+
+    # Validate the username and password
+    if not utils.validate_username(username):
+        log.error("Invalid username")
+        return render_template('register.html', error="Invalid username")
+
+    # Check if the user already exists
+    user = db.execute_query("SELECT * FROM users WHERE username = ?", (username,), fetch_type=FETCHONE)
+    if user:
+        log.error("User already exists")
+        return render_template('register.html', error="User already exists")
+
+    # Create the user
+    db.execute_query("INSERT INTO users (username, password) VALUES (?, ?)", (username, password))
+    log.info(f"User {username} registered successfully")
+
+    # Log in the user
+    user = db.execute_query("SELECT * FROM users WHERE username = ?", (username,), fetch_type=FETCHONE)
+    token = urandom(16).hex()
+    db.execute_query("UPDATE users SET token = ? WHERE id = ?", (token, user[0]))
+    log.debug(f"Token generated for user {username}")
+
+    session['user_id'] = user[0]
+    session['name'] = user[1]    # Log in the user
+    session['perms'] = user[4]
+    session['token'] = token
+    log.info(f"User {username} logged in")
+
+    return redirect('/')
+
+
+@app.route('/logout', methods=['GET'])
+def logout():
+    log.debug("Logging out user")
+    # Log out the user
+    session.clear()
+    return render_template('index.html')
+
+
+@app.route('/settings', methods=['GET'])
+def settings():
+    log.debug("Rendering settings page")
+    # Check if the user is logged in
+    if 'token' not in session:
+        log.error("User not logged in")
+        return redirect('/login')
+    # Render the settings page
+    return render_template('settings.html')
+
+
+@app.route('/settings', methods=['POST'])
+def settings_post():
+    log.debug("Processing settings form")
+    # Process the settings form
+    option = request.form.get('type')
+    if not option:
+        log.error("No option provided")
+        return render_template('settings.html', error="No option provided")
+    token = session['token']
+    if not token:
+        log.error("Token not found")
+        return render_template('settings.html', error="Token not found")
+    
+    # Validate the token
+    user = db.execute_query("SELECT * FROM users WHERE id = ? AND token = ?", (session['user_id'], token), fetch_type=FETCHONE)
+    if not user:
+        log.error("Invalid token")
+        return render_template('settings.html', error="Invalid token")
+    log.debug(f"Token validated for user {user[1]}")
+
+    if option == 'username':
+        username = request.form.get('username')
+        if not username:
+            log.error("No username provided")
+            return render_template('settings.html', error="No username provided")
+        if not utils.validate_username(username):
+            log.error("Invalid username format")
+            return render_template('settings.html', error="Invalid username format")
+        
+        # Check if the username already exists
+        existing_user = db.execute_query("SELECT * FROM users WHERE username = ?", (username,), fetch_type=FETCHONE)
+        if existing_user:
+            log.error("Username already exists")
+            return render_template('settings.html', error="Username already exists")
+        
+        # Update the username
+        db.execute_query("UPDATE users SET username = ? WHERE id = ?", (username, session['user_id']))
+        session['name'] = username
+        log.debug(f"Username updated to {username}")
+
+    elif option == 'password':
+        password = request.form.get('password')
+        if not password:
+            log.error("No password provided")
+            return render_template('settings.html', error="No password provided")
+
+        # Hash the password
+        try:
+            password = password.encode()
+        except AttributeError:
+            log.error("Password encoding failed")
+            return render_template('settings.html', error="Password encoding failed")
+        password = hashlib.sha256(password).hexdigest()
+        
+        # Update the password
+        db.execute_query("UPDATE users SET password = ? WHERE id = ?", (password, session['user_id']))
+        log.debug("Password updated successfully")
+
+    elif option == 'avatar':
+        # Get the file from the request
+        file = request.files.get('avatar')
+        if not file:
+            log.error("No file uploaded")
+            return render_template('settings.html', error="No file uploaded")
+        if file.mimetype not in ['image/png', 'image/jpeg', 'image/jpg', 'image/gif']:
+            log.error("Invalid file type")
+            return render_template('settings.html', error="Invalid file type")
+
+        file_data = file.read()
+        if not file:
+            log.error("File is empty")
+            return render_template('settings.html', error="File is empty")
+        
+        # Validate the file size 12mb
+        if len(file_data) > 12 * 1024 * 1024:
+            log.error("File is too large")
+            return render_template('settings.html', error="File is too large")
+
+        # Save the file to the database
+        db.execute_query("UPDATE users SET avatar = ?, avatar_type = ? WHERE id = ?", (file_data, file.mimetype, session['user_id']))
+        log.debug("Avatar updated successfully")
+
+    elif option == 'about':
+        about = request.form.get('about')
+        if not about:
+            log.error("No about text provided")
+            return render_template('settings.html', error="No about text provided")
+
+        # Update the about text
+        db.execute_query("UPDATE users SET about = ? WHERE id = ?", (about, session['user_id']))
+        log.debug("About text updated successfully")
+
+    elif option == 'delete':
+        # Delete the user
+        db.execute_query("DELETE FROM users WHERE id = ?", (session['user_id'],))
+        log.debug("User deleted successfully")
+        session.clear()
+        return redirect('/')
+    
+    else:
+        log.error("Invalid option")
+        return render_template('settings.html', error="Invalid option")
+
+    return render_template('settings.html', success="Settings updated successfully")
+
+
+@app.route('/users/<int:user_id>/avatar')
+def user_avatar(user_id):
+    log.debug(f"Rendering avatar for user ID {user_id}")
+    # Get the user from the database
+    user = db.execute_query("SELECT * FROM users WHERE id = ?", (user_id,), fetch_type=FETCHONE)
+    if not user:
+        log.error(f"User {user_id} not found")
+        return "User not found", 404
+
+    # Render the avatar page
+    file = BytesIO(user[5])
+    return send_file(
+        file,
+        mimetype=user[8],
+        as_attachment=False,
+        download_name=f"{user[1]}_avatar.{user[8].split('/')[1]}"  # Extract the file extension from the MIME type
+    )
+
+
+@app.route('/boards/new', methods=['GET'])
+def new_board():
+    log.debug("Rendering new board page")
+    # Check if the user is logged in
+    if 'token' not in session:
+        log.error("User not logged in")
+        return redirect('/login')
+    # Render the new board page
+    return render_template('new_board.html')
+
+
+@app.route('/boards/new', methods=['POST'])
+def new_board_post():
+    log.debug("Processing new board form")
+    # Check if the user is logged in
+    if 'token' not in session:
+        log.error("User not logged in")
+        return redirect('/login')
+    
+    # Validate the token
+    user = db.execute_query("SELECT * FROM users WHERE id = ? AND token = ?", (session['user_id'], session['token']), fetch_type=FETCHONE)
+    if not user:
+        log.error("Invalid token")
+        return redirect('/login')
+    log.debug(f"Token validated for user {user[1]}")
+
+    # Process the new board form
+    name = request.form.get('name')
+    if not name:
+        log.error("No board name provided")
+        return render_template('new_board.html', error="No board name provided")
+    description = request.form.get('description')
+    if not description:
+        log.error("No board description provided")
+        return render_template('new_board.html', error="No board description provided")
+    
+    # Validate the board name
+    if not utils.validate_board_name(name):
+        log.error("Invalid board name format")
+        return render_template('new_board.html', error="Invalid board name format")
+
+    # Check if the board already exists
+    board = db.execute_query("SELECT * FROM boards WHERE name = ?", (name,), fetch_type=FETCHONE)
+    if board:
+        log.error("Board already exists")
+        return render_template('new_board.html', error="Board already exists")
+
+    # Create the board
+    db.execute_query("INSERT INTO boards (name, description, owner_id) VALUES (?, ?, ?)", (name, description, session['user_id']))
+    log.info(f"Board {name} created successfully")
+
+    return redirect('/boards')
+
+
+@app.route('/boards/delete/<int:board_id>', methods=['GET'])
+def delete_board(board_id):
+    log.debug(f"Processing delete board request for board ID {board_id}")
+    # Check if the user is logged in
+    if 'token' not in session:
+        log.error("User not logged in")
+        return redirect('/login')
+    
+    # Validate the token
+    user = db.execute_query("SELECT * FROM users WHERE id = ? AND token = ?", (session['user_id'], session['token']), fetch_type=FETCHONE)
+    if not user:
+        log.error("Invalid token")
+        return redirect('/login')
+    log.debug(f"Token validated for user {user[1]}")
+
+    # Delete the board
+    db.execute_query("DELETE FROM boards WHERE id = ?", (board_id,))
+    log.info(f"Board ID {board_id} deleted successfully")
+
+    return redirect('/boards')
+
+
+@app.route('/post', methods=['POST'])
+def new_post():
+    log.debug("Processing new post form")
+    # Check if the user is logged in
+    if 'token' not in session:
+        log.error("User not logged in")
+        return redirect('/login')
+    
+    # Validate the token
+    user = db.execute_query("SELECT * FROM users WHERE id = ? AND token = ?", (session['user_id'], session['token']), fetch_type=FETCHONE)
+    if not user:
+        log.error("Invalid token")
+        return redirect('/login')
+    log.debug(f"Token validated for user {user[1]}")
+
+    # Process the new post form
+    board_id = request.form.get('board_id')
+    if not board_id:
+        log.error("No board ID provided")
+        return render_template('error.html', error="No board ID provided")
+    
+    # Validate the board ID
+    try:
+        board_id = int(board_id)
+        # Check if the board exists
+        board = db.execute_query("SELECT * FROM boards WHERE id = ?", (board_id,), fetch_type=FETCHONE)
+        if not board:
+            log.error("Invalid board ID")
+            return render_template('error.html', error="Invalid board ID")
+
+    except ValueError:
+        log.error("Invalid board ID")
+        return render_template('error.html', error="Invalid board ID")
+    
+    log.debug(f"Board ID {board_id} validated")
+    
+    content = request.form.get('content')
+    if not content:
+        log.error("No post content provided")
+        return render_template('error.html', error="No post content provided")
+    
+    attachments = request.files.getlist('attachments')
+
+    reference = request.form.get('reference')
+    if reference:
+        try:
+            reference = int(reference)
+            # Validate the reference ID
+            post = db.execute_query("SELECT * FROM posts WHERE id = ?", (reference,), fetch_type=FETCHONE)
+            if not post:
+                log.error("Invalid reference ID")
+                return render_template('error.html', error="Invalid reference ID")
+            
+            log.debug(f"Reference ID {reference} validated")
+
+        except ValueError:
+            log.error("Invalid reference ID")
+            return render_template('error.html', error="Invalid reference ID")
+    else:
+        reference = None
+
+    post_type = request.form.get('type', 'post')
+    if post_type not in ['post', 'comment']:
+        log.error("Invalid post type")
+        return render_template('error.html', error="Invalid post type")
+    
+    # create the post
+    db.execute_query(
+        "INSERT INTO posts (user_id, board_id, content, reference, type) VALUES (?, ?, ?, ?, ?)", 
+        (session['user_id'], board_id, content, reference, post_type))
+
+    # get the post ID
+    post_id = db.cursor.lastrowid
+    log.debug(f"Post ID {post_id} created successfully")
+
+    # upload attachments
+    for attachment in attachments:
+        # Validate the file size 12mb
+        file = attachment.read()
+        if not file:
+            continue
+        
+        if len(file) > 12 * 1024 * 1024:
+            log.error("Attachment is too large")
+            # Delete the post if the attachment is too large
+            db.execute_query("DELETE FROM posts WHERE id = ?", (post_id,))
+            log.debug(f"Post ID {post_id} deleted due to large attachment")
+
+            return render_template('error.html', error="Attachment is too large")
+
+        # Save the file to the database
+        db.execute_query("INSERT INTO attachments (post_id, file_name, file_data, file_type) VALUES (?, ?, ?, ?)", (post_id, attachment.filename, file, attachment.mimetype))
+        log.debug(f"Attachment {attachment.filename} uploaded successfully")    
+
+    # get the board name
+    board = db.execute_query("SELECT * FROM boards WHERE id = ?", (board_id,), fetch_type=FETCHONE)
+    if not board:
+        log.error("Invalid board ID")
+        return render_template('error.html', error="Invalid board ID")
+
+    return redirect(f'/boards/{board[1]}')
+
+
 @app.route('/delete/post/<int:post_id>', methods=['GET'])
 def delete_post(post_id):
-    logger.info("Deleting post ID: %s", post_id)
-    token = session.get('session')
-    if not token:
-        logger.error("Session token is missing.")
-        return "Session expired. Please log in again.", 403
+    log.debug(f"Processing delete post request for post ID {post_id}")
+    # Check if the user is logged in
+    if 'token' not in session:
+        log.error("User not logged in")
+        return redirect('/login')
+    
+    # Validate the token
+    user = db.execute_query("SELECT * FROM users WHERE id = ? AND token = ?", (session['user_id'], session['token']), fetch_type=FETCHONE)
+    if not user:
+        log.error("Invalid token")
+        return redirect('/login')
+    log.debug(f"Token validated for user {user[1]}")
 
-    user = db.get_session(token)
-    if user is None:
-        logger.error("Session not found or expired.")
-        return "Session expired. Please log in again.", 403
+    # Delete the post
+    db.execute_query("DELETE FROM posts WHERE id = ?", (post_id,))
+    log.info(f"Post ID {post_id} deleted successfully")
 
-    user_id = user[0]
-    post = db.get_post(post_id)
-    if post is None:
-        logger.error("Post not found: %s", post_id)
-        return "Post not found", 404
-
-    if post[1] != user_id and user_id != SYSTEMUID:
-        logger.error("User %s is not allowed to delete this post.", user_id)
-        return "You are not allowed to delete this post.", 403
-
-    db.delete_post(post_id)
-    logger.info("Post ID %s deleted successfully.", post_id)
-
-    return redirect('/posts')
+    redirect_url = request.referrer
+    if not redirect_url:
+        redirect_url = '/posts'
+    return redirect(redirect_url)
 
 
-# Main function
+@app.route('/error/<error_message>')
+def error(error_message):
+    log.debug(f"Rendering error page with message: {error_message}")
+    # Render the error page
+    return render_template('error.html', error=error_message)
+
+
+# Run the app
 if __name__ == '__main__':
-    logger.info("Starting Flask app...")
-    app.run(host=os.getenv('FLASK_HOST', '0.0.0.0'), port=int(os.getenv('FLASK_PORT', 5000)), debug=os.getenv('FLASK_DEBUG', 'false').lower() == 'true')
\ No newline at end of file
+    pass
\ No newline at end of file
diff --git a/src/static/content/default_avatar.png b/src/static/content/default_avatar.png
new file mode 100644
index 0000000..73330fd
Binary files /dev/null and b/src/static/content/default_avatar.png differ
diff --git a/src/static/base.css b/src/static/css/base.css
similarity index 51%
rename from src/static/base.css
rename to src/static/css/base.css
index 5608950..046eeab 100644
--- a/src/static/base.css
+++ b/src/static/css/base.css
@@ -2,6 +2,10 @@
     --bg: #000;
     --fg: #fff;
     --accent: #7139f3;
+    --admin: #39f3da;
+    --user: #5b6dd4;
+    --board: #515699;
+    --time: #30597a;
 }
 
 body {
@@ -83,11 +87,18 @@ a {
     text-decoration: none;
     transition: all 0.3s ease;
 }
+
 a:hover {
-    color: var(--fg);
+    opacity: 0.6;
 }
 
-ul.posts {
+div#nav {
+    display: flex;
+    gap: 10px;
+    margin-top: 20px;
+}
+
+ul.board-list {
     list-style: none;
     padding: 0;
     margin: 0;
@@ -97,90 +108,41 @@ ul.posts {
     gap: 10px;
 }
 
-form {
+ul.post-list {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+    margin-left: 10px;
     display: flex;
     flex-direction: column;
     gap: 10px;
 }
 
-input[type="text"],
-input[type="password"] {
-    padding: 10px;
-    border: 1px solid var(--fg);
-    border-radius: 5px;
-    box-sizing: border-box;
-    background-color: var(--bg);
-    color: var(--fg);
-    font-size: 1rem;
-    width: 300px;
+.user-admin {
+    color: var(--admin);
 }
 
-input[type="text"]:focus,
-input[type="password"]:focus {
-    outline: none;
-    border-color: var(--accent);
+.user-user {
+    color: var(--user);
 }
 
-button[type="submit"] {
-    padding: 10px 20px;
-    border: none;
-    border-radius: 5px;
-    background-color: var(--accent);
-    color: var(--bg);
-    font-size: 1rem;
-    cursor: pointer;
-    transition: background-color 0.3s ease;
-    width: 300px;
-    font-weight: 600;
+.board-name {
+    color: var(--board);
 }
 
-button[type="submit"]:hover {
-    background-color: var(--fg);
-    color: var(--bg);
-}
-button[type="submit"]:disabled {
-    background-color: var(--bg);
-    color: var(--fg);
-    cursor: not-allowed;
+.time {
+    color: var(--time);
 }
 
-select {
-    padding: 10px;
-    border: 1px solid var(--fg);
-    border-radius: 5px;
-    background-color: var(--bg);
-    color: var(--fg);
-    font-size: 1rem;
-    width: 300px;
+#title {
+    background: linear-gradient(90deg, var(--accent), var(--admin));
+    background-clip: text;
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
 }
 
-select:focus {
-    outline: none;
-    border-color: var(--accent);
-}
-
-textarea {
-    padding: 10px;
-    border: 1px solid var(--fg);
-    border-radius: 5px;
-    background-color: var(--bg);
-    color: var(--fg);
-    font-size: 1rem;
-    width: 300px;
-    height: 100px;
-}
-
-textarea:focus {
-    outline: none;
-    border-color: var(--accent);
-}
-
-div#nav {
+.attachments {
     display: flex;
     gap: 10px;
-    margin-top: 20px;
-}
-
-p {
-    white-space:pre;
+    align-items: center;
 }
\ No newline at end of file
diff --git a/src/static/css/form.css b/src/static/css/form.css
new file mode 100644
index 0000000..223d2e5
--- /dev/null
+++ b/src/static/css/form.css
@@ -0,0 +1,89 @@
+form {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+
+input[type="text"],
+input[type="password"] {
+    padding: 10px;
+    border: 1px solid var(--fg);
+    border-radius: 5px;
+    box-sizing: border-box;
+    background-color: var(--bg);
+    color: var(--fg);
+    font-size: 1rem;
+    width: 300px;
+}
+
+input[type="text"]:focus,
+input[type="password"]:focus {
+    outline: none;
+    border-color: var(--accent);
+}
+
+button[type="submit"] {
+    padding: 10px 20px;
+    border: none;
+    border-radius: 5px;
+    background: linear-gradient(90deg, var(--accent), var(--admin));
+    color: var(--bg);
+    font-size: 1rem;
+    cursor: pointer;
+    transition: all 0.3s ease;
+    width: 300px;
+    font-weight: 600;
+}
+
+button[type="submit"]:hover {
+    transform: scale(1.05);
+}
+button[type="submit"]:disabled {
+    background-color: var(--bg);
+    color: var(--fg);
+    cursor: not-allowed;
+}
+
+select {
+    padding: 10px;
+    border: 1px solid var(--fg);
+    border-radius: 5px;
+    background-color: var(--bg);
+    color: var(--fg);
+    font-size: 1rem;
+    width: 300px;
+}
+
+select:focus {
+    outline: none;
+    border-color: var(--accent);
+}
+
+textarea {
+    padding: 10px;
+    border: 1px solid var(--fg);
+    border-radius: 5px;
+    background-color: var(--bg);
+    color: var(--fg);
+    font-size: 1rem;
+    width: 300px;
+    height: 150px;
+    box-sizing: border-box;
+}
+
+textarea:focus {
+    outline: none;
+    border-color: var(--accent);
+}
+
+input[type="file"] {
+    padding: 10px;
+    border: 1px solid var(--fg);
+    border-radius: 5px;
+    background-color: var(--bg);
+    color: var(--fg);
+    font-size: 1rem;
+    width: 300px;
+    cursor: pointer;
+    box-sizing: border-box;
+}
\ No newline at end of file
diff --git a/src/static/css/index.css b/src/static/css/index.css
new file mode 100644
index 0000000..23103da
--- /dev/null
+++ b/src/static/css/index.css
@@ -0,0 +1,7 @@
+ul.stats {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+    display: flex;
+    flex-direction: column;
+}
\ No newline at end of file
diff --git a/src/static/css/user.css b/src/static/css/user.css
new file mode 100644
index 0000000..155ceb3
--- /dev/null
+++ b/src/static/css/user.css
@@ -0,0 +1,27 @@
+.user {
+    display: flex;
+    gap: 20px;
+    align-items: center;
+    border: 1px solid var(--fg);
+    width: fit-content;
+    max-width: 100%;
+    padding: 10px;
+    margin-bottom: 10px;
+}
+
+.user img {
+    height: 80px;
+    max-width: 300px;
+}
+
+a.user {
+    text-decoration: none;
+    color: var(--fg);
+    transition: all 0.3s ease;
+}
+
+a.user:hover {
+    opacity: 1;
+    transform: scale(1.05);
+    border-color: var(--accent);
+}
\ No newline at end of file
diff --git a/src/utils.py b/src/utils.py
new file mode 100644
index 0000000..86a2274
--- /dev/null
+++ b/src/utils.py
@@ -0,0 +1,145 @@
+import logging, re, database, datetime, os
+from dateutil import tz
+
+
+log = logging.getLogger(__name__)
+STRING = re.compile(r'^[\w ]+$')
+STRING_NO_SPACE = re.compile(r'^[\w]+$')
+TZ = os.getenv('TZ', 'UTC')
+
+
+def convert_utc_to_local(utc_dt:str, local_tz:str) -> str:
+    utc_dt = datetime.datetime.strptime(utc_dt, '%Y-%m-%d %H:%M:%S')
+
+    log.debug(f"Converting UTC datetime {utc_dt} to local timezone {local_tz}")
+    if not isinstance(utc_dt, datetime.datetime):
+        raise ValueError("utc_dt must be a datetime object")
+    
+    if not isinstance(local_tz, str):
+        raise ValueError("local_tz must be a string")
+    
+    local_tz = tz.gettz(local_tz)
+    if local_tz is None:
+        raise ValueError(f"Invalid timezone: {local_tz}")
+    
+    local_dt = utc_dt.replace(tzinfo=tz.tzutc()).astimezone(local_tz)
+    log.debug(f"Converted datetime: {local_dt}")
+    return local_dt.strftime('%Y-%m-%d %H:%M:%S')
+
+
+def validate_string(input_string:str, allowed_regex:re.Pattern=STRING, max_length:int=None, min_length:int=None) -> bool:
+    if max_length and len(input_string) > max_length:
+        return False
+    if min_length and len(input_string) < min_length:
+        return False
+    if not re.match(allowed_regex, input_string):
+        return False
+    return True
+
+
+def validate_board_name(board_name:str) -> bool:
+    log.debug(f"Validating board name: {board_name}")
+    return validate_string(board_name, allowed_regex=STRING_NO_SPACE, max_length=20, min_length=3)
+
+
+def validate_username(username:str) -> bool:
+    log.debug(f"Validating username: {username}")
+    return validate_string(username, allowed_regex=STRING_NO_SPACE, max_length=20, min_length=3)
+
+
+class data_converter:
+    def __init__(self, db:database.Database):
+        self.db = db
+
+    def board_to_dict(self, board):
+        return {
+            'id': board[0],
+            'name': board[1],
+            'description': board[2],
+            'created_at': convert_utc_to_local(board[3], 'Europe/London'),
+            'owner_id': board[4]
+        }
+    
+    def post_to_dict(self, post, show_reference:bool=True):
+        log.debug(f"Converting post with id ({post[0]}) to dict")
+        data = {
+            'id': post[0],
+            'content': post[3],
+            'short_content': post[3][:50] + '...' if len(post[3]) > 50 else post[3],
+            'created_at': convert_utc_to_local(post[6], 'Europe/London'),
+            'type': post[5],
+        }
+
+        # Get the user who created the post
+        user = self.db.execute_query("SELECT * FROM users WHERE id = ?", (post[1],), fetch_type=database.FETCHONE)
+        if user:
+            data['user'] = {
+                'id': user[0],
+                'name': user[1],
+                'about': user[3],
+                'avatar_url': '/users/' + str(user[0]) + '/avatar' if user[5] else None,
+                'perms': user[4],
+            }
+        else:
+            data['user'] = None
+
+        # Get the board where the post was created
+        board = self.db.execute_query("SELECT * FROM boards WHERE id = ?", (post[2],), fetch_type=database.FETCHONE)
+        if board:
+            data['board'] = {
+                'id': board[0],
+                'name': board[1],
+                'description': board[2],
+                'created_at': convert_utc_to_local(board[3], 'Europe/London'),
+                'owner_id': board[4]
+            }
+        else:
+            data['board'] = None
+    
+        # Get the reference post if it exists
+        if post[4]:
+            reference_post = self.db.execute_query("SELECT * FROM posts WHERE id = ?", (post[4],), fetch_type=database.FETCHONE)
+            if reference_post:
+                data['reference'] = {
+                    'id': reference_post[0],
+                    'content': reference_post[3],
+                    'short_content': reference_post[3][:25] + '...' if len(reference_post[3]) > 25 else reference_post[3],
+                    'created_at': convert_utc_to_local(reference_post[6], 'Europe/London'),
+                    'type': reference_post[5],
+                    'show': show_reference
+                }
+            else:
+                data['reference'] = None
+        else:
+            data['reference'] = None
+
+        # Get the attachments for the post
+        attachments = self.db.execute_query("SELECT * FROM attachments WHERE post_id = ?", (post[0],), fetch_type=database.FETCHALL)
+        data['attachments'] = []
+        for attachment in attachments:
+            data['attachments'].append({
+                'id': attachment[0],
+                'file_name': attachment[3],
+                'created_at': convert_utc_to_local(attachment[5], 'Europe/London'),
+                'url': '/attachment/' + str(attachment[0]),
+                'type': attachment[4].split('/')[0],
+                'mime_type': attachment[4]
+            })
+
+        # Get the number of replies to the post
+        replies = self.db.execute_query("SELECT COUNT(*) FROM posts WHERE reference = ?", (post[0],), fetch_type=database.FETCHONE)
+        data['replies'] = replies[0] if replies else 0
+        log.debug(f"Post converted to dict")
+        return data
+    
+
+    def user_to_dict(self, user):
+        return {
+            'id': user[0],
+            'name': user[1],
+            'about': user[3],
+            'avatar_url': '/users/' + str(user[0]) + '/avatar' if user[5] else None,
+            'perms': user[4],
+            'created_at': convert_utc_to_local(user[6], 'Europe/London'),
+            'avatar_type': user[8],
+        }
\ No newline at end of file