diff --git a/.clang-format b/.clang-format
index a84b477..37d4bf7 100644
--- a/.clang-format
+++ b/.clang-format
@@ -7,7 +7,5 @@ SeparateDefinitionBlocks: Always
 AllowShortBlocksOnASingleLine: Never
 AllowShortIfStatementsOnASingleLine: false
 AllowShortFunctionsOnASingleLine: None
+AllowShortLambdasOnASingleLine: Empty
 AlignAfterOpenBracket: BlockIndent
-AlignOperands: AlignAfterOperator
-BreakBeforeBinaryOperators: NonAssignment
-AllowAllArgumentsOnNextLine: true
diff --git a/external/mirai-core/CMakeLists.txt b/external/mirai-core/CMakeLists.txt
index d6317c9..6fc217d 100644
--- a/external/mirai-core/CMakeLists.txt
+++ b/external/mirai-core/CMakeLists.txt
@@ -8,12 +8,14 @@ set(CMAKE_COMPILE_WARNING_AS_ERROR ON)
 add_library(mirai-core 
 	src/Mirai.cpp
 	src/Task.cpp
+	src/Day.cpp
 	src/Event.cpp
 	src/DateTime.cpp
 	src/EventEmitter.cpp 
 	src/Source.cpp 
 	src/MarkdownDataProvider.cpp 
 	src/MarkdownDataProvider.Parser.cpp 
+	src/View.cpp
 	src/utils.cpp
 )
 
diff --git a/external/mirai-core/include/mirai-core/DataProvider.h b/external/mirai-core/include/mirai-core/DataProvider.h
index d206f3b..a2798db 100644
--- a/external/mirai-core/include/mirai-core/DataProvider.h
+++ b/external/mirai-core/include/mirai-core/DataProvider.h
@@ -14,83 +14,103 @@
 namespace mirai
 {
 
-enum task_state { TODO, DONE };
-
-struct task_data {
-	int id;
-	std::string title;
-	task_state state;
-	std::optional<Date> due_date;
-};
-
-struct updatable_task_data {
-	std::optional<std::string> title = std::nullopt;
-	std::optional<task_state> state = std::nullopt;
-	std::optional<std::optional<Date>> due_date = std::nullopt;
-};
-
-struct event_data {
+struct DayData {
 	int id;
 	Date date;
-	std::string title;
-	Time starts_at;
-	Time ends_at;
 };
 
-struct updatable_event_data {
+struct UpdatableDayData {
 	std::optional<Date> date;
-	std::optional<std::string> title;
-	std::optional<Time> starts_at;
-	std::optional<Time> ends_at;
 };
 
-class data_provider
+enum TaskState { TODO, DONE };
+
+struct TaskData {
+	int id;
+	std::string title;
+	TaskState state;
+	std::optional<int> dayId;
+	std::optional<int> eventId;
+};
+
+struct UpdatableTaskData {
+	std::optional<std::string> title = std::nullopt;
+	std::optional<TaskState> state = std::nullopt;
+	std::optional<std::optional<int>> dayId = std::nullopt;
+	std::optional<std::optional<int>> eventId = std::nullopt;
+};
+
+struct EventData {
+	int id;
+	int dayId;
+	std::string title;
+	Time startsAt;
+	Time endsAt;
+};
+
+struct UpdatableEventData {
+	std::optional<int> dayId;
+	std::optional<std::string> title;
+	std::optional<Time> startsAt;
+	std::optional<Time> endsAt;
+};
+
+class DataProvider
 {
 
   public:
-	data_provider() {};
-	data_provider(data_provider &) = delete;
-	data_provider(data_provider &&) = delete;
+	DataProvider() {};
+	DataProvider(DataProvider &) = delete;
+	DataProvider(DataProvider &&) = delete;
 
-	virtual ~data_provider() = default;
+	virtual ~DataProvider() = default;
 	virtual void save() = 0;
 	virtual void load() = 0;
 
 	virtual std::string name() const = 0;
 
 	// Tasks
-	virtual task_data insert_task(const task_data &task) = 0;
-	virtual void remove_task_by_id(int taskId) = 0;
-	virtual std::optional<task_data> get_task_by_id(int taskId) = 0;
-	virtual std::vector<task_data> get_tasks_by_date(Date date) = 0;
-	virtual std::vector<task_data> get_tasks_without_date() = 0;
-	virtual std::vector<task_data> get_tasks() = 0;
-	virtual void update_task(int taskId, updatable_task_data updateData) = 0;
+	virtual TaskData insertTask(const TaskData &task) = 0;
+	virtual void removeTaskById(int taskId) = 0;
+	virtual std::optional<TaskData> getTaskById(int taskId) = 0;
+	virtual std::vector<TaskData> getTasksByEventId(int eventId) = 0;
+	virtual std::vector<TaskData> getTasksByDayId(int dayId) = 0;
+	virtual std::vector<TaskData> getTasksByDate(Date date) = 0;
+	virtual std::vector<TaskData> getTasksWithoutDate() = 0;
+	virtual std::vector<TaskData> getTasks() = 0;
+	virtual void updateTask(int taskId, UpdatableTaskData updateData) = 0;
 
 	// Events
-	virtual event_data insertEvent(const event_data &task) = 0;
-	virtual void remove_event_by_id(int eventId) = 0;
-	virtual std::optional<event_data> get_event_by_id(int eventId) = 0;
-	virtual std::vector<event_data> get_events() = 0;
-	virtual std::vector<event_data> get_events_by_date(Date date) = 0;
-	virtual void update_event(int eventId, updatable_event_data updateData) = 0;
+	virtual EventData insertEvent(const EventData &task) = 0;
+	virtual void removeEventById(int eventId) = 0;
+	virtual std::optional<EventData> getEventById(int eventId) = 0;
+	virtual std::vector<EventData> getEvents() = 0;
+	virtual std::vector<EventData> getEventsByDate(Date date) = 0;
+	virtual void updateEvent(int eventId, UpdatableEventData updateData) = 0;
 
-	const int id = data_provider::generate_next_id();
+	// Days
+	virtual DayData insertDay(const DayData &day) = 0;
+	virtual void removeDayById(int dayId) = 0;
+	virtual std::vector<DayData> getDays() = 0;
+	virtual std::optional<DayData> getDayByDate(const Date &date) = 0;
+	virtual void updateDay(int dayId, UpdatableDayData updateData) = 0;
 
-	void set_dirty(bool dirty)
+	const int id = DataProvider::generateNextId();
+
+	void setDirty(bool dirty)
 	{
-		_is_dirty = dirty;
+		isDirty_ = dirty;
 	};
 
-	bool is_dirty() const
+	bool isDirty() const
 	{
-		return _is_dirty;
+		return isDirty_;
 	};
 
   private:
-	bool _is_dirty = false;
+	bool isDirty_ = false;
 
-	static int generate_next_id()
+	static int generateNextId()
 	{
 		static int nextId = 0;
 		return nextId++;
diff --git a/external/mirai-core/include/mirai-core/Day.h b/external/mirai-core/include/mirai-core/Day.h
new file mode 100644
index 0000000..a95f64f
--- /dev/null
+++ b/external/mirai-core/include/mirai-core/Day.h
@@ -0,0 +1,38 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+
+#include "DataProvider.h"
+#include <vector>
+
+namespace mirai
+{
+
+class Task;
+class Event;
+
+class Day
+{
+
+  public:
+	Day(DataProvider *data, DayData day) : data_(data), dayData_(day) {};
+
+	Date date() const;
+	std::vector<Task> tasks();
+	std::vector<Event> events();
+
+	void mergeDay(const Day &otherDay);
+
+	int id() const;
+	int sourceId() const;
+
+  private:
+	DayData dayData_;
+	DataProvider *data_;
+};
+
+} // namespace mirai
diff --git a/external/mirai-core/include/mirai-core/Event.h b/external/mirai-core/include/mirai-core/Event.h
index 3d00064..a2023cd 100644
--- a/external/mirai-core/include/mirai-core/Event.h
+++ b/external/mirai-core/include/mirai-core/Event.h
@@ -7,6 +7,7 @@
 #pragma once
 
 #include "DataProvider.h"
+#include "Day.h"
 #include <string>
 #include <vector>
 
@@ -19,26 +20,25 @@ class Event
 {
 
   public:
-	Event(data_provider *provider, event_data data) : _provider(provider), _data(data) {};
+	Event(DataProvider *data, EventData eventData) : data_(data), eventData_(eventData) {};
 
 	std::string title() const;
-	Date date() const;
-	Time starts_at() const;
-	Time ends_at() const;
+	Time startsAt() const;
+	Time endsAt() const;
 
-	std::vector<Task> query_tasks() const;
+	std::vector<Task> queryTasks() const;
 
-	void set_title(const std::string &newTitle);
-	void set_date(const Date &date);
-	void set_start_time(const Time &time);
-	void set_end_time(const Time &time);
+	void setTitle(const std::string &newTitle);
+	void setDay(const Day &day);
+	void setStartTime(const Time &time);
+	void setEndTime(const Time &time);
 
 	int id() const;
-	int source_id() const;
+	int sourceId() const;
 
   private:
-	event_data _data;
-	data_provider *_provider;
+	EventData eventData_;
+	DataProvider *data_;
 };
 
 } // namespace mirai
diff --git a/external/mirai-core/include/mirai-core/MarkdownDataProvider.h b/external/mirai-core/include/mirai-core/MarkdownDataProvider.h
index 501a88f..a88da83 100644
--- a/external/mirai-core/include/mirai-core/MarkdownDataProvider.h
+++ b/external/mirai-core/include/mirai-core/MarkdownDataProvider.h
@@ -19,21 +19,22 @@
 namespace mirai
 {
 
-struct markdown_data {
+struct MarkdownData {
 	std::string name;
-	std::vector<task_data> tasks;
-	std::vector<event_data> events;
+	std::vector<TaskData> tasks;
+	std::vector<DayData> days;
+	std::vector<EventData> events;
 };
 
-class markdown_data_provider final : public data_provider
+class MarkdownDataProvider : public DataProvider
 {
   public:
-	markdown_data_provider(const std::string &file_path) : _file_path(file_path), data_provider()
+	MarkdownDataProvider(const std::string &filePath) : filePath_(filePath), DataProvider()
 	{
 	}
 
-	std::string to_markdown();
-	markdown_data parse_markdown(const std::string &content);
+	std::string toMarkdown();
+	MarkdownData parseMarkdown(const std::string &content);
 
 	std::string path() const;
 
@@ -43,26 +44,35 @@ class markdown_data_provider final : public data_provider
 	std::string name() const override;
 
 	// Tasks
-	task_data insert_task(const task_data &task) override;
-	void remove_task_by_id(int taskId) override;
-	std::optional<task_data> get_task_by_id(int taskId) override;
-	std::vector<task_data> get_tasks_by_date(Date date) override;
-	std::vector<task_data> get_tasks_without_date() override;
-	std::vector<task_data> get_tasks() override;
-	void update_task(int taskId, updatable_task_data updateData) override;
+	TaskData insertTask(const TaskData &task) override;
+	void removeTaskById(int taskId) override;
+	std::optional<TaskData> getTaskById(int taskId) override;
+	std::vector<TaskData> getTasksByEventId(int eventId) override;
+	std::vector<TaskData> getTasksByDayId(int dayId) override;
+	std::vector<TaskData> getTasksByDate(Date date) override;
+	std::vector<TaskData> getTasksWithoutDate() override;
+	std::vector<TaskData> getTasks() override;
+	void updateTask(int taskId, UpdatableTaskData updateData) override;
 
 	// Events
-	event_data insertEvent(const event_data &task) override;
-	void remove_event_by_id(int eventId) override;
-	std::optional<event_data> get_event_by_id(int eventId) override;
-	std::vector<event_data> get_events() override;
-	std::vector<event_data> get_events_by_date(Date date) override;
-	void update_event(int eventId, updatable_event_data updateData) override;
+	EventData insertEvent(const EventData &task) override;
+	void removeEventById(int eventId) override;
+	std::optional<EventData> getEventById(int eventId) override;
+	std::vector<EventData> getEvents() override;
+	std::vector<EventData> getEventsByDate(Date date) override;
+	void updateEvent(int eventId, UpdatableEventData updateData) override;
+
+	// Days
+	DayData insertDay(const DayData &day) override;
+	void removeDayById(int dayId) override;
+	std::vector<DayData> getDays() override;
+	std::optional<DayData> getDayByDate(const Date &date) override;
+	void updateDay(int dayId, UpdatableDayData updateData) override;
 
   private:
-	std::string _name;
-	std::string _file_path;
-	markdown_data _data;
+	std::string name_;
+	std::string filePath_;
+	MarkdownData data;
 };
 
 } // namespace mirai
diff --git a/external/mirai-core/include/mirai-core/Mirai.h b/external/mirai-core/include/mirai-core/Mirai.h
index 83d3551..b0a39e7 100644
--- a/external/mirai-core/include/mirai-core/Mirai.h
+++ b/external/mirai-core/include/mirai-core/Mirai.h
@@ -22,7 +22,7 @@ class Mirai
   public:
 	Mirai(const std::string &configFilePath);
 	void addSource(
-		const std::string &name, const std::string &type, std::unique_ptr<data_provider> &&source
+		const std::string &name, const std::string &type, std::unique_ptr<DataProvider> &&source
 	);
 	void
 	editSource(int id, const std::string &name, const std::string &color, const std::string &path);
@@ -30,25 +30,25 @@ class Mirai
 	void unloadAllSources();
 	void save();
 
-	std::vector<std::unique_ptr<source>> &getSources();
+	std::vector<std::unique_ptr<Source>> &getSources();
 	const std::vector<std::string> &getTags();
 
 	// Returns a non owning pointer to the requested resource or nullptr if not found.
-	source *getSourceById(int id);
-	source *getSourceByName(const std::string &name);
+	Source *getSourceById(int id);
+	Source *getSourceByName(const std::string &name);
 
-	void onSourceAdded(std::function<void(source *)> f);
-	void onSourceEdited(std::function<void(source *)> f);
+	void onSourceAdded(std::function<void(Source *)> f);
+	void onSourceEdited(std::function<void(Source *)> f);
 	void onSourceDeleted(std::function<void(int)> f);
 
   private:
 	void loadConfig(const std::string &path);
 	void saveConfig();
-	std::vector<std::unique_ptr<source>> sources_;
+	std::vector<std::unique_ptr<Source>> sources_;
 	std::string configPath_;
 
-	EventEmitter<source *> sourceAdded;
-	EventEmitter<source *> sourceEdited;
+	EventEmitter<Source *> sourceAdded;
+	EventEmitter<Source *> sourceEdited;
 	EventEmitter<int> sourceDeleted;
 };
 } // namespace mirai
diff --git a/external/mirai-core/include/mirai-core/Source.h b/external/mirai-core/include/mirai-core/Source.h
index b06264a..3a32b4c 100644
--- a/external/mirai-core/include/mirai-core/Source.h
+++ b/external/mirai-core/include/mirai-core/Source.h
@@ -8,6 +8,7 @@
 
 #include "DataProvider.h"
 #include "DateTime.h"
+#include "Day.h"
 #include "Event.h"
 #include "Task.h"
 #include <string>
@@ -16,39 +17,40 @@
 namespace mirai
 {
 
-struct create_task_params {
+struct createTaskParams {
 	std::string title;
-	std::optional<Date> due_date;
+	std::optional<Event> event;
+	std::optional<Date> date;
 };
 
-struct create_event_params {
+struct createEventParams {
 	std::string title;
 	Date date;
-	Time starts_at;
-	Time ends_at;
+	Time startsAt;
+	Time endsAt;
 };
 
-struct source_constructor {
+struct SourceConstructor {
 	std::string name;
 	std::string color;
-	data_provider *source_data_provider;
+	DataProvider *sourceDataProvider;
 };
 
-class source
+class Source
 {
   public:
-	source(source_constructor params)
-		: data(params.source_data_provider), _name(params.name), _color(params.color),
-		  _type("FileSystemMarkdown")
+	Source(SourceConstructor params)
+		: data(params.sourceDataProvider), name_(params.name), color_(params.color),
+		  type_("FileSystemMarkdown")
 	{
 	}
 
-	source(source &) = delete;
-	source(source &&) = delete;
-	source operator=(source &) = delete;
-	source operator=(source &&) = delete;
+	Source(Source &) = delete;
+	Source(Source &&) = delete;
+	Source operator=(Source &) = delete;
+	Source operator=(Source &&) = delete;
 
-	~source() = default;
+	~Source() = default;
 
 	void init();
 	void save();
@@ -57,41 +59,44 @@ class source
 	std::string name() const;
 	std::string type() const;
 	std::string color() const;
-	class data_provider *data_provider();
+	DataProvider *dataProvider();
 
-	void set_name(const std::string &name);
-	void set_color(const std::string &color);
+	void setName(const std::string &name);
+	void setColor(const std::string &color);
 
-	void create_task(const create_task_params &task);
-	void remove_task(const Task &task);
-	std::optional<Task> get_task_by_id(int taskId);
-	std::vector<Task> get_tasks_by_date(Date date);
-	std::vector<Task> get_unscheduled_tasks();
-	std::vector<Task> get_tasks();
+	void createTask(const createTaskParams &task);
+	void removeTask(const Task &task);
+	std::optional<Task> getTaskById(int taskId);
+	std::vector<Task> getTasksByDate(Date date);
+	std::vector<Task> getUnscheduledTasks();
+	std::vector<Task> getTasks();
 
-	void create_event(const create_event_params &eventToCreate);
-	void remove_event(const Event &event);
-	std::vector<Event> get_events();
-	std::optional<Event> get_event_by_id(int eventId);
-	std::vector<Event> get_events_by_date(Date date);
+	void createEvent(const createEventParams &eventToCreate);
+	void removeEvent(const Event &event);
+	std::vector<Event> getEvents();
+	std::optional<Event> getEventById(int eventId);
+	std::vector<Event> getEventsByDate(Date date);
 
-	const int id = source::generate_next_id();
+	std::vector<Day> getDays();
+	std::optional<Day> getDayByDate(Date date);
 
-	bool is_dirty() const
+	const int id = Source::generateNextId();
+
+	bool isDirty() const
 	{
-		return data->is_dirty();
+		return data->isDirty();
 	};
 
   private:
-	static int generate_next_id()
+	static int generateNextId()
 	{
 		static int nextId = 0;
 		return nextId++;
 	}
 
-	std::string _name;
-	std::string _type;
-	std::string _color;
-	class data_provider *data;
+	std::string name_;
+	std::string type_;
+	std::string color_;
+	DataProvider *data;
 };
 } // namespace mirai
diff --git a/external/mirai-core/include/mirai-core/Task.h b/external/mirai-core/include/mirai-core/Task.h
index 754fae3..cd9588f 100644
--- a/external/mirai-core/include/mirai-core/Task.h
+++ b/external/mirai-core/include/mirai-core/Task.h
@@ -7,9 +7,7 @@
 #pragma once
 
 #include "DataProvider.h"
-#include "DateTime.h"
 #include "Event.h"
-#include <optional>
 #include <string>
 
 namespace mirai
@@ -21,25 +19,27 @@ class Task
 {
 
   public:
-	Task(data_provider *data, task_data task) : data_(data), task_(task) {};
+	Task(DataProvider *data, TaskData task) : data_(data), task_(task) {};
 
 	std::string title() const;
-	mirai::task_state state() const;
+	mirai::TaskState state() const;
 	bool checked() const;
-	bool has_due_date() const;
-	std::optional<Date> due_date() const;
+	bool hasEvent() const;
+	bool hasDate() const;
 
-	void set_title(const std::string &newTitle);
-	void set_date(const Date &date);
-	void set_checked(bool checked);
+	void setTitle(const std::string &newTitle);
+	void setDay(const Day &day);
+	void setDate(const Date &date);
+	void setEvent(const Event &event);
+	void setChecked(bool checked);
 	void unschedule();
 
 	int id() const;
-	int source_id() const;
+	int sourceId() const;
 
   private:
-	task_data task_;
-	data_provider *data_;
+	TaskData task_;
+	DataProvider *data_;
 };
 
 } // namespace mirai
diff --git a/external/mirai-core/include/mirai-core/View.h b/external/mirai-core/include/mirai-core/View.h
new file mode 100644
index 0000000..cd1295d
--- /dev/null
+++ b/external/mirai-core/include/mirai-core/View.h
@@ -0,0 +1,58 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#pragma once
+#include "Mirai.h"
+#include "Task.h"
+#include <algorithm>
+#include <iterator>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace mirai
+{
+
+struct DateView {
+	std::vector<Task> tasks;
+	std::vector<Event> events;
+};
+
+class View
+{
+
+  public:
+	View(Mirai *mirai);
+
+	void hideCompletedTasks(bool hide);
+	bool shouldHideCompletedTasks() const;
+
+	std::vector<Date> getDates();
+
+	std::vector<Task> getTasksForDate(const Date &date);
+	std::vector<Event> getEventsForDate(const Date &date);
+	std::vector<Task> getUnscheduledTasks();
+
+	void update();
+
+	void removeSources();
+	void addSource(const Source &source);
+	void setSources(const std::vector<Source> &sources);
+	void setAllSources();
+	bool isSourceSelected(const Source &source) const;
+
+	size_t activeSourceCount() const;
+
+  private:
+	Mirai *mirai_;
+	std::vector<int> sourcesIds_;
+	std::vector<Task> unscheduledTasks_;
+	std::map<Date, DateView> dates;
+
+	bool shouldHideCompletedTasks_ = true;
+};
+} // namespace mirai
diff --git a/external/mirai-core/include/mirai-core/utils.h b/external/mirai-core/include/mirai-core/utils.h
index 4bde63f..14a48c7 100644
--- a/external/mirai-core/include/mirai-core/utils.h
+++ b/external/mirai-core/include/mirai-core/utils.h
@@ -6,14 +6,11 @@
 
 #pragma once
 
-#include "DataProvider.h"
-#include "DateTime.h"
 #include <cctype>
 #include <cpp-utils/string.h>
 #include <cpp-utils/vector.h>
 #include <functional>
 #include <optional>
-#include <vector>
 
 namespace mirai
 {
@@ -48,6 +45,6 @@ template <typename T, typename F> std::vector<T> findAll(std::vector<T> containe
 	return result;
 }
 
-int generate_unique_id();
+int generateUniqueId();
 
 } // namespace mirai
diff --git a/external/mirai-core/src/Day.cpp b/external/mirai-core/src/Day.cpp
new file mode 100644
index 0000000..1086cb4
--- /dev/null
+++ b/external/mirai-core/src/Day.cpp
@@ -0,0 +1,60 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "Day.h"
+#include "Task.h"
+#include <algorithm>
+#include <stdexcept>
+
+namespace mirai
+{
+
+int Day::id() const
+{
+	return dayData_.id;
+}
+
+int Day::sourceId() const
+{
+	return data_->id;
+}
+
+Date Day::date() const
+{
+	return dayData_.date;
+}
+
+std::vector<Task> Day::tasks()
+{
+	auto tasksData = data_->getTasksByDayId(id());
+	std::vector<Task> tasks;
+	std::transform(
+		tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
+		[&](const TaskData &taskData) {
+			return Task{data_, taskData};
+		}
+	);
+	return tasks;
+}
+
+std::vector<Event> Day::events()
+{
+	auto eventsData = data_->getEventsByDate(dayData_.date);
+	std::vector<Event> events;
+	std::transform(
+		eventsData.begin(), eventsData.end(), std::back_inserter(events),
+		[&](const EventData &eventData) {
+			return Event{data_, eventData};
+		}
+	);
+	return events;
+}
+
+void Day::mergeDay(const Day &otherDay)
+{
+	throw std::runtime_error("Not implemented yet");
+}
+} // namespace mirai
diff --git a/external/mirai-core/src/Event.cpp b/external/mirai-core/src/Event.cpp
index b87fcf4..f5b0021 100644
--- a/external/mirai-core/src/Event.cpp
+++ b/external/mirai-core/src/Event.cpp
@@ -13,51 +13,59 @@ namespace mirai
 
 int Event::id() const
 {
-	return _data.id;
+	return eventData_.id;
 }
 
-int Event::source_id() const
+int Event::sourceId() const
 {
-	return _provider->id;
+	return data_->id;
 }
 
 std::string Event::title() const
 {
-	return _data.title;
+	return eventData_.title;
 }
 
-Date Event::date() const
+Time Event::startsAt() const
 {
-	return _data.date;
+	return eventData_.startsAt;
 }
 
-Time Event::starts_at() const
+Time Event::endsAt() const
 {
-	return _data.starts_at;
+	return eventData_.endsAt;
 }
 
-Time Event::ends_at() const
+std::vector<Task> Event::queryTasks() const
 {
-	return _data.ends_at;
+	auto tasksData = data_->getTasksByEventId(eventData_.id);
+	std::vector<Task> tasks;
+	std::transform(
+		tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
+		[&](const TaskData &taskData) {
+			return Task{data_, taskData};
+		}
+	);
+	return tasks;
 }
 
-void Event::set_title(const std::string &newTitle)
+void Event::setTitle(const std::string &newTitle)
 {
-	_provider->update_event(id(), {.title = newTitle});
+	data_->updateEvent(id(), {.title = newTitle});
 }
 
-void Event::set_date(const Date &date)
+void Event::setDay(const Day &day)
 {
-	_provider->update_event(id(), {.date = date});
+	data_->updateEvent(id(), {.dayId = day.id()});
 }
 
-void Event::set_start_time(const Time &time)
+void Event::setStartTime(const Time &time)
 {
-	_provider->update_event(id(), {.starts_at = time});
+	data_->updateEvent(id(), {.startsAt = time});
 }
 
-void Event::set_end_time(const Time &time)
+void Event::setEndTime(const Time &time)
 {
-	_provider->update_event(id(), {.ends_at = time});
+	data_->updateEvent(id(), {.endsAt = time});
 }
 } // namespace mirai
diff --git a/external/mirai-core/src/MarkdownDataProvider.Parser.cpp b/external/mirai-core/src/MarkdownDataProvider.Parser.cpp
index d96518d..e1bd7d4 100644
--- a/external/mirai-core/src/MarkdownDataProvider.Parser.cpp
+++ b/external/mirai-core/src/MarkdownDataProvider.Parser.cpp
@@ -7,7 +7,6 @@
 #include "MarkdownDataProvider.h"
 #include "cpp-utils/debug.h"
 #include "utils.h"
-#include <optional>
 #include <print>
 #include <regex>
 
@@ -38,17 +37,16 @@ std::string fieldWithSpace(const std::string &field)
 	return (field + " ");
 }
 
-task_data stringToTask(const std::string &str, const std::string &date)
+TaskData stringToTask(const std::string &str, const std::string &date)
 {
 	std::smatch matches;
-	std::regex regex(
-		"- \\[(\\s|X)\\] (([0-9]{2}:[0-9]{2})-([0-9]{2}:[0-9]{2}) > )?(.*?)( -- (.*))?"
+	std::regex regex("- \\[(\\s|X)\\] (([0-9]{2}:[0-9]{2})-([0-9]{2}:[0-9]{2}) > )?(.*?)( -- (.*))?"
 	);
 	std::regex_match(str, matches, regex);
 
 	std::string text = stringUtils::trim(matches[5]);
 
-	task_data taskItem{
+	TaskData taskItem{
 		.title = text,
 		.state = str.substr(0, 5) == "- [X]" ? DONE : TODO,
 	};
@@ -71,7 +69,7 @@ Time stringToTime(const std::string &str)
 	return time;
 }
 
-event_data stringToEvent(const std::string &str, const std::string &dateString)
+EventData stringToEvent(const std::string &str, const std::string &dateString)
 {
 	std::smatch matches;
 	std::regex regex("> (([0-9]{2}h[0-9]{2})-([0-9]{2}h[0-9]{2}) )(.*?)( -- (.*))?");
@@ -85,86 +83,68 @@ event_data stringToEvent(const std::string &str, const std::string &dateString)
 		throw std::runtime_error("Malformated date");
 	}
 
-	event_data eventData{
-		.date = date.value(),
+	EventData eventData{
 		.title = text,
-		.starts_at = stringToTime(matches[2]),
-		.ends_at = stringToTime(matches[3]),
+		.startsAt = stringToTime(matches[2]),
+		.endsAt = stringToTime(matches[3]),
 	};
 	return eventData;
 }
 
-std::string taskToString(const task_data &task)
+std::string taskToString(const TaskData &task)
 {
 	std::string str = task.title;
 	str = (task.state == DONE ? "- [X] " : "- [ ] ") + str;
 	return str;
 }
 
-std::string markdown_data_provider::to_markdown()
+std::string MarkdownDataProvider::toMarkdown()
 {
+	const std::vector<DayData> days = getDays();
 	std::string result = "# " + name() + "\n\n";
 	std::string currentDate = "";
 
-	int next_task_index = 0;
-	int next_event_index = 0;
-
-	while (next_event_index < _data.events.size() || next_task_index < _data.tasks.size()) {
-		std::optional<Date> current_date = std::nullopt;
-		// First we find the lowest date between the events and the tasks
-		if (_data.events.size() > 0 && next_event_index < _data.events.size()) {
-			current_date = _data.events.at(next_event_index).date;
+	for (const auto &day : days) {
+		auto &date = day.date;
+		auto tasks = getTasksByDayId(day.id);
+		auto events = getEventsByDate(date);
+		if (tasks.size() == 0 && events.size() == 0) {
+			continue;
 		}
-		if (_data.tasks.size() > 0 && next_task_index < _data.tasks.size()) {
-			auto &task = _data.tasks.at(next_task_index);
-			if (task.due_date.has_value() && task.due_date < current_date.value()) {
-				current_date = _data.tasks.at(next_task_index).due_date;
-			}
-		}
-
-		if (current_date.has_value()) {
-			result += "## "
-					+ std::format(
-						  "{:02d}-{:02d}-{:02d}", current_date.value().year,
-						  current_date.value().month, current_date.value().day
-					)
-					+ "\n\n";
-		} else {
-			result += "## Unscheduled\n\n";
-		}
-
-		while (next_event_index < _data.events.size()) {
-			auto &current_event = _data.events.at(next_event_index);
-			if (current_event.date != current_date) {
-				break;
-			}
-			auto &start = current_event.starts_at;
-			auto &end = current_event.ends_at;
-			result += "> "
-					+ std::format(
+		result +=
+			"## " + std::format("{:02d}-{:02d}-{:02d}", date.year, date.month, date.day) + "\n\n";
+		for (auto event : events) {
+			auto &start = event.startsAt;
+			auto &end = event.endsAt;
+			result += "> " +
+					  std::format(
 						  "{:02d}h{:02d}-{:02d}h{:02d} {}", start.hour, start.minute, end.hour,
-						  end.minute, current_event.title
-					)
-					+ "\n";
-			next_event_index++;
-			current_event = _data.events.at(next_event_index);
-		}
-		while (next_task_index < _data.tasks.size()) {
-			auto &current_task = _data.tasks.at(next_task_index);
-			if (current_task.due_date != current_date) {
-				break;
+						  end.minute, event.title
+					  ) +
+					  "\n";
+			for (const auto &task : getTasksByEventId(event.id)) {
+				result += taskToString(task) + '\n';
 			}
-			taskToString(current_task);
-			next_event_index++;
-			current_task = _data.tasks.at(next_task_index);
+			result += '\n';
+		}
+		for (const auto &task : tasks) {
+			result += taskToString(task) + '\n';
 		}
 		result += '\n';
 	}
 
+	auto unscheduledTasks = getTasksWithoutDate();
+	if (unscheduledTasks.size() > 0) {
+		result += "## Unscheduled\n\n";
+		for (const auto &task : unscheduledTasks) {
+			result += taskToString(task) + '\n';
+		}
+		result += '\n';
+	}
 	return result;
 };
 
-markdown_data markdown_data_provider::parse_markdown(const std::string &content)
+MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
 {
 	cpputils::debug::Timer readMdFormatDuration;
 
@@ -176,10 +156,13 @@ markdown_data markdown_data_provider::parse_markdown(const std::string &content)
 		std::println("Couldn't find the task list name");
 	}
 
-	_data.name = line.substr(2);
+	data.name = line.substr(2);
 	std::string currentDateString = "";
 
-	std::optional<Date> current_date = std::nullopt;
+	std::vector<mirai::DayData> daysData;
+	std::vector<mirai::TaskData> unscheduledTasks;
+	std::optional<Date> currentDate = std::nullopt;
+	std::optional<EventData> currentEvent = std::nullopt;
 
 	cpputils::debug::Timer stringToTaskDuration;
 	stringToTaskDuration.reset();
@@ -188,40 +171,64 @@ markdown_data markdown_data_provider::parse_markdown(const std::string &content)
 		if (std::string_view{line.data(), 3} == "## ") {
 			currentDateString = line.substr(3);
 			if (currentDateString == "Unscheduled") {
-				current_date = std::nullopt;
+				currentDate = std::nullopt;
 				continue;
 			}
-			current_date = mirai::stringToDate(currentDateString);
-			if (!current_date.has_value()) {
+			currentDate = mirai::stringToDate(currentDateString);
+			if (!currentDate.has_value()) {
 				throw std::runtime_error("Malformated date (1)");
 			}
+			insertDay({.id = generateUniqueId(), .date = currentDate.value()});
 		} else if (line.starts_with("> ")) {
 			auto event = stringToEvent(line, currentDateString);
-			if (current_date.has_value()) {
-				insertEvent(
-					{.id = generate_unique_id(),
-					 .date = current_date.value(),
+			if (currentDate.has_value()) {
+				auto day = getDayByDate(currentDate.value());
+				currentEvent = insertEvent(
+					{.id = generateUniqueId(),
+					 .dayId = day->id,
 					 .title = event.title,
-					 .starts_at = event.starts_at,
-					 .ends_at = event.ends_at}
+					 .startsAt = event.startsAt,
+					 .endsAt = event.endsAt}
 				);
 			}
 		} else if (line.starts_with("- [ ]") || line.starts_with("- [X]")) {
 			stringToTaskDuration.start();
-			task_data taskItemData = stringToTask(line, currentDateString);
+			TaskData taskItemData = stringToTask(line, currentDateString);
 			stringToTaskDuration.stop();
-			insert_task(
-				{.id = generate_unique_id(),
-				 .title = taskItemData.title,
-				 .state = taskItemData.state,
-				 .due_date = current_date}
-			);
+			if (currentEvent.has_value()) {
+				insertTask({
+					.id = generateUniqueId(),
+					.title = taskItemData.title,
+					.state = taskItemData.state,
+					.dayId = std::nullopt,
+					.eventId = currentEvent.value().id,
+				});
+			} else if (currentDate.has_value()) {
+				auto day = getDayByDate(currentDate.value());
+				insertTask({
+					.id = generateUniqueId(),
+					.title = taskItemData.title,
+					.state = taskItemData.state,
+					.dayId = day->id,
+					.eventId = std::nullopt,
+				});
+			} else {
+				insertTask({
+					.id = generateUniqueId(),
+					.title = taskItemData.title,
+					.state = taskItemData.state,
+					.dayId = std::nullopt,
+					.eventId = std::nullopt,
+				});
+			}
+		} else if (cpputils::string::trim(line) == "") {
+			currentEvent = std::nullopt;
 		}
 	}
 
 	gelinesDuration.printTimeElapsed("getlinesDuration");
 	stringToTaskDuration.printTimeElapsed("stringToTaskDuration");
 	readMdFormatDuration.printTimeElapsed("Reading MD File duration");
-	return _data;
+	return data;
 }
 } // namespace mirai
diff --git a/external/mirai-core/src/MarkdownDataProvider.cpp b/external/mirai-core/src/MarkdownDataProvider.cpp
index ce676bc..d72c3cf 100644
--- a/external/mirai-core/src/MarkdownDataProvider.cpp
+++ b/external/mirai-core/src/MarkdownDataProvider.cpp
@@ -18,33 +18,33 @@
 namespace mirai
 {
 
-std::string markdown_data_provider::path() const
+std::string MarkdownDataProvider::path() const
 {
-	return _file_path;
+	return filePath_;
 }
 
-std::string markdown_data_provider::name() const
+std::string MarkdownDataProvider::name() const
 {
-	return _data.name;
+	return data.name;
 }
 
-void markdown_data_provider::save()
+void MarkdownDataProvider::save()
 {
-	std::ofstream file(_file_path);
+	std::ofstream file(filePath_);
 	if (!file.is_open()) {
-		throw std::runtime_error("can't create " + _file_path);
+		throw std::runtime_error("can't create " + filePath_);
 	}
 
-	const std::string content = to_markdown();
+	const std::string content = toMarkdown();
 
 	file << content;
 	file.close();
-	set_dirty(false);
+	setDirty(false);
 };
 
-void markdown_data_provider::load()
+void MarkdownDataProvider::load()
 {
-	std::ifstream file(_file_path);
+	std::ifstream file(filePath_);
 	if (!file.is_open()) {
 		return;
 	}
@@ -55,19 +55,19 @@ void markdown_data_provider::load()
 		content += line + "\n";
 	}
 	file.close();
-	_data = parse_markdown(content);
+	data = parseMarkdown(content);
 };
 
-task_data markdown_data_provider::insert_task(const task_data &taskData)
+TaskData MarkdownDataProvider::insertTask(const TaskData &taskData)
 {
-	_data.tasks.push_back(taskData);
-	set_dirty(true);
+	data.tasks.push_back(taskData);
+	setDirty(true);
 	return taskData;
 }
 
-void markdown_data_provider::update_task(int taskId, updatable_task_data updateData)
+void MarkdownDataProvider::updateTask(int taskId, UpdatableTaskData updateData)
 {
-	auto taskData = ptrFindFirst(_data.tasks, [&](const task_data &task) {
+	auto taskData = ptrFindFirst(data.tasks, [&](const TaskData &task) {
 		return task.id == taskId;
 	});
 	assert(taskData != nullptr); // Shouldn't be possible
@@ -77,110 +77,180 @@ void markdown_data_provider::update_task(int taskId, updatable_task_data updateD
 	if (updateData.state.has_value()) {
 		taskData->state = updateData.state.value();
 	}
-	if (updateData.due_date.has_value()) {
-		taskData->due_date = updateData.due_date.value();
+	if (updateData.dayId.has_value()) {
+		taskData->dayId = updateData.dayId.value();
 	}
-	set_dirty(true);
+	if (updateData.eventId.has_value()) {
+		taskData->eventId = updateData.eventId.value();
+	}
+	setDirty(true);
 }
 
-std::optional<task_data> markdown_data_provider::get_task_by_id(int taskId)
+std::optional<TaskData> MarkdownDataProvider::getTaskById(int taskId)
 {
-	return findFirst(_data.tasks, [&](const task_data &task) {
+	return findFirst(data.tasks, [&](const TaskData &task) {
 		return task.id == taskId;
 	});
 }
 
-std::vector<task_data> markdown_data_provider::get_tasks_without_date()
+std::vector<TaskData> MarkdownDataProvider::getTasksByEventId(int eventId)
 {
-	return findAll(_data.tasks, [](const task_data &t) {
-		return t.due_date == std::nullopt;
+	return findAll(data.tasks, [&](const TaskData &task) {
+		return task.eventId == eventId;
 	});
 }
 
-std::vector<task_data> markdown_data_provider::get_tasks_by_date(Date date)
+std::vector<TaskData> MarkdownDataProvider::getTasksByDayId(int dayId)
 {
-	return findAll(_data.tasks, [&](const task_data &t) {
-		return t.due_date == date;
+	return findAll(data.tasks, [&](const TaskData &task) {
+		return task.dayId == dayId;
 	});
 }
 
-std::vector<task_data> markdown_data_provider::get_tasks()
+std::vector<TaskData> MarkdownDataProvider::getTasksWithoutDate()
 {
-	return _data.tasks;
+	return findAll(data.tasks, [](const TaskData &t) {
+		return t.dayId == std::nullopt && t.eventId == std::nullopt;
+	});
 }
 
-void markdown_data_provider::remove_task_by_id(int taskId)
+std::vector<TaskData> MarkdownDataProvider::getTasksByDate(Date date)
 {
-	_data.tasks.erase(
+	auto day = getDayByDate(date);
+	if (!day.has_value()) {
+		return {};
+	}
+	return findAll(data.tasks, [&](const TaskData &t) {
+		return t.dayId == day.value().id;
+	});
+}
+
+std::vector<TaskData> MarkdownDataProvider::getTasks()
+{
+	return data.tasks;
+}
+
+void MarkdownDataProvider::removeTaskById(int taskId)
+{
+	data.tasks.erase(
 		std::remove_if(
-			_data.tasks.begin(), _data.tasks.end(),
-			[&](const task_data &task) {
+			data.tasks.begin(), data.tasks.end(),
+			[&](const TaskData &task) {
 				return task.id == taskId;
 			}
 		),
-		_data.tasks.end()
+		data.tasks.end()
 	);
-	set_dirty(true);
+	setDirty(true);
 }
 
-event_data markdown_data_provider::insertEvent(const event_data &eventData)
+DayData MarkdownDataProvider::insertDay(const DayData &dayData)
 {
-	_data.events.push_back(eventData);
-	set_dirty(true);
+	data.days.push_back(dayData);
+	setDirty(true);
+	return dayData;
+}
+
+void MarkdownDataProvider::updateDay(int dayId, UpdatableDayData updateData)
+{
+	auto dayData = ptrFindFirst(data.days, [&](const DayData &day) {
+		return day.id == dayId;
+	});
+	assert(dayData != nullptr); // Shouldn't be possible
+	if (updateData.date.has_value()) {
+		dayData->date = updateData.date.value();
+	}
+	setDirty(true);
+}
+
+void MarkdownDataProvider::removeDayById(int dayId)
+{
+	data.days.erase(
+		std::remove_if(
+			data.days.begin(), data.days.end(),
+			[&](const DayData &day) {
+				return day.id == dayId;
+			}
+		),
+		data.days.end()
+	);
+	setDirty(true);
+}
+
+std::vector<DayData> MarkdownDataProvider::getDays()
+{
+	return data.days;
+}
+
+std::optional<DayData> MarkdownDataProvider::getDayByDate(const Date &date)
+{
+	return findFirst(data.days, [&](const DayData &day) {
+		return day.date == date;
+	});
+}
+
+EventData MarkdownDataProvider::insertEvent(const EventData &eventData)
+{
+	data.events.push_back(eventData);
+	setDirty(true);
 	return eventData;
 }
 
-void markdown_data_provider::update_event(int eventId, updatable_event_data updateData)
+void MarkdownDataProvider::updateEvent(int eventId, UpdatableEventData updateData)
 {
-	auto eventData = ptrFindFirst(_data.events, [&](const event_data &event) {
+	auto eventData = ptrFindFirst(data.events, [&](const EventData &event) {
 		return event.id == eventId;
 	});
 	assert(eventData != nullptr); // Shouldn't be possible
 	if (updateData.title.has_value()) {
 		eventData->title = updateData.title.value();
 	}
-	if (updateData.date.has_value()) {
-		eventData->date = updateData.date.value();
+	if (updateData.dayId.has_value()) {
+		eventData->dayId = updateData.dayId.value();
 	}
-	if (updateData.starts_at.has_value()) {
-		eventData->starts_at = updateData.starts_at.value();
+	if (updateData.startsAt.has_value()) {
+		eventData->startsAt = updateData.startsAt.value();
 	}
-	if (updateData.ends_at.has_value()) {
-		eventData->ends_at = updateData.ends_at.value();
+	if (updateData.endsAt.has_value()) {
+		eventData->endsAt = updateData.endsAt.value();
 	}
-	set_dirty(true);
+	setDirty(true);
 }
 
-void markdown_data_provider::remove_event_by_id(int eventId)
+void MarkdownDataProvider::removeEventById(int eventId)
 {
-	_data.events.erase(
+	data.events.erase(
 		std::remove_if(
-			_data.events.begin(), _data.events.end(),
-			[&](const event_data &event) {
+			data.events.begin(), data.events.end(),
+			[&](const EventData &event) {
 				return event.id == eventId;
 			}
 		),
-		_data.events.end()
+		data.events.end()
 	);
-	set_dirty(true);
+	setDirty(true);
 }
 
-std::optional<event_data> markdown_data_provider::get_event_by_id(int eventId)
+std::optional<EventData> MarkdownDataProvider::getEventById(int eventId)
 {
-	return findFirst(_data.events, [&](const event_data &event) {
+	return findFirst(data.events, [&](const EventData &event) {
 		return event.id == eventId;
 	});
 }
 
-std::vector<event_data> markdown_data_provider::get_events_by_date(Date date)
+std::vector<EventData> MarkdownDataProvider::getEventsByDate(Date date)
 {
-	return findAll(_data.events, [&](const event_data &event) {
-		return event.date == date;
+	auto day = getDayByDate(date);
+	if (!day.has_value()) {
+		return {};
+	}
+	return findAll(data.events, [&](const EventData &event) {
+		return event.dayId == day.value().id;
 	});
 }
 
-std::vector<event_data> markdown_data_provider::get_events()
+std::vector<EventData> MarkdownDataProvider::getEvents()
 {
-	return _data.events;
+	return data.events;
 }
 } // namespace mirai
diff --git a/external/mirai-core/src/Mirai.cpp b/external/mirai-core/src/Mirai.cpp
index 25954c0..5f7683a 100644
--- a/external/mirai-core/src/Mirai.cpp
+++ b/external/mirai-core/src/Mirai.cpp
@@ -43,12 +43,12 @@ void Mirai::loadConfig(const std::string &path)
 		const auto name = filePath.asObject().getString("name");
 		const auto color = filePath.asObject().getString("color");
 		const auto path = filePath.asObject().getString("path");
-		std::unique_ptr<data_provider> file = std::make_unique<markdown_data_provider>(path);
-		data_provider *sourceDataProvider = file.release();
+		std::unique_ptr<DataProvider> file = std::make_unique<MarkdownDataProvider>(path);
+		DataProvider *sourceDataProvider = file.release();
 		sourceDataProvider->load();
 		sources_.push_back(
-			std::make_unique<source>(source_constructor{
-				.name = name, .color = color, .source_data_provider = sourceDataProvider
+			std::make_unique<Source>(SourceConstructor{
+				.name = name, .color = color, .sourceDataProvider = sourceDataProvider
 			})
 		);
 	}
@@ -69,7 +69,7 @@ void Mirai::saveConfig()
 		rei::json::JsonObject jsonSource;
 		jsonSource.set("name", source->name());
 		jsonSource.set("color", source->color());
-		auto dataProvider = dynamic_cast<markdown_data_provider *>(source->data_provider());
+		auto dataProvider = dynamic_cast<MarkdownDataProvider *>(source->dataProvider());
 		jsonSource.set("path", dataProvider->path());
 		jsonSource.set("type", "FileSystemMarkdown");
 		configJson.getArray("files").push(jsonSource);
@@ -84,14 +84,14 @@ Mirai::Mirai(const std::string &configFilePath) : configPath_(configFilePath)
 }
 
 void Mirai::addSource(
-	const std::string &name, const std::string &type, std::unique_ptr<data_provider> &&new_source
+	const std::string &name, const std::string &type, std::unique_ptr<DataProvider> &&source
 )
 {
-	data_provider *sourceDataProvider = new_source.release();
+	DataProvider *sourceDataProvider = source.release();
 	sourceDataProvider->load();
 	sources_.push_back(
-		std::make_unique<source>(
-			source_constructor{.name = name, .source_data_provider = sourceDataProvider}
+		std::make_unique<Source>(
+			SourceConstructor{.name = name, .sourceDataProvider = sourceDataProvider}
 		)
 	);
 	saveConfig();
@@ -103,20 +103,23 @@ void Mirai::editSource(
 )
 {
 	auto source = getSourceById(id);
-	source->set_name(name);
-	source->set_color(color);
+	source->setName(name);
+	source->setColor(color);
 
-	data_provider *sourceDataProvider = source->data_provider();
+	DataProvider *sourceDataProvider = source->dataProvider();
 	saveConfig();
 	sourceEdited.emit(nullptr);
 }
 
 void Mirai::deleteSource(int id)
 {
+	auto source = getSourceById(id);
 	sources_.erase(
 		std::remove_if(
 			sources_.begin(), sources_.end(),
-			[&](const std::unique_ptr<source> &source) { return source->id == id; }
+			[&](const std::unique_ptr<Source> &source) {
+				return source->id == id;
+			}
 		),
 		sources_.end()
 	);
@@ -133,47 +136,47 @@ void Mirai::unloadAllSources()
 void Mirai::save()
 {
 	for (auto &source : sources_) {
-		if (source->is_dirty()) {
+		if (source->isDirty()) {
 			source->save();
 		}
 	}
 }
 
-std::vector<std::unique_ptr<source>> &Mirai::getSources()
+std::vector<std::unique_ptr<Source>> &Mirai::getSources()
 {
 	return sources_;
 }
 
-source *Mirai::getSourceById(int id)
+Source *Mirai::getSourceById(int id)
 {
-	auto source_found = std::ranges::find_if(sources_, [&](const std::unique_ptr<source> &source) {
+	auto source = std::ranges::find_if(sources_, [&](const std::unique_ptr<Source> &source) {
 		return source->id == id;
 	});
-	// assert(source_found != sources_.end()); // This should not happen
-	if (source_found == sources_.end()) {
+	assert(source != sources_.end()); // This should not happen
+	if (source == sources_.end()) {
 		return nullptr;
 	}
-	return source_found->get();
+	return source->get();
 }
 
-source *Mirai::getSourceByName(const std::string &name)
+Source *Mirai::getSourceByName(const std::string &name)
 {
-	auto source_found = std::ranges::find_if(sources_, [&](const std::unique_ptr<source> &source) {
+	auto source = std::ranges::find_if(sources_, [&](const std::unique_ptr<Source> &source) {
 		return source->name() == name;
 	});
-	assert(source_found != sources_.end()); // This should not happen
-	if (source_found == sources_.end()) {
+	assert(source != sources_.end()); // This should not happen
+	if (source == sources_.end()) {
 		return nullptr;
 	}
-	return source_found->get();
+	return source->get();
 }
 
-void Mirai::onSourceAdded(std::function<void(source *)> f)
+void Mirai::onSourceAdded(std::function<void(Source *)> f)
 {
 	sourceAdded.registerCallback(f);
 }
 
-void Mirai::onSourceEdited(std::function<void(source *)> f)
+void Mirai::onSourceEdited(std::function<void(Source *)> f)
 {
 	sourceEdited.registerCallback(f);
 }
diff --git a/external/mirai-core/src/Source.cpp b/external/mirai-core/src/Source.cpp
index 25314ac..9ced168 100644
--- a/external/mirai-core/src/Source.cpp
+++ b/external/mirai-core/src/Source.cpp
@@ -16,65 +16,99 @@
 namespace mirai
 {
 
-void source::save()
+void Source::save()
 {
 	data->save();
 }
 
-void source::create_task(const create_task_params &task)
+void Source::createTask(const createTaskParams &task)
 {
-	data->insert_task({
-		.id = generate_unique_id(),
+	std::optional<int> dayId = std::nullopt;
+	std::optional<int> eventId = std::nullopt;
+
+	if (!task.event.has_value() && task.date.has_value()) {
+		auto day = data->getDayByDate(task.date.value());
+		if (!day.has_value() && task.date.has_value()) {
+			day = data->insertDay({.id = generateUniqueId(), .date = task.date.value()});
+		}
+		dayId = day->id;
+	}
+
+	if (task.event.has_value() && task.event->id()) {
+		eventId = task.event.value().id();
+	}
+
+	data->insertTask({
+		.id = generateUniqueId(),
 		.title = task.title,
 		.state = TODO,
-		.due_date = task.due_date,
+		.dayId = dayId,
+		.eventId = eventId,
 	});
 };
 
-void source::create_event(const create_event_params &new_event)
+std::vector<Day> Source::getDays()
 {
-	data->insertEvent({
-		.id = generate_unique_id(),
-		.date = new_event.date,
-		.title = new_event.title,
-		.starts_at = new_event.starts_at,
-		.ends_at = new_event.ends_at,
-	});
-};
-
-std::vector<Event> source::get_events()
-{
-	auto event_data = data->get_events();
-	std::vector<Event> events;
+	auto daysData = data->getDays();
+	std::vector<Day> days;
 	std::transform(
-		event_data.begin(), event_data.end(), std::back_inserter(events),
-		[&](const struct event_data &event_data) { return Event{data, event_data}; }
+		daysData.begin(), daysData.end(), std::back_inserter(days), [&](const DayData &dayData) {
+			return Day{data, dayData};
+		}
 	);
-	return events;
+	return days;
 }
 
-std::optional<Event> source::get_event_by_id(int evendId)
+std::optional<Day> Source::getDayByDate(Date date)
 {
-	auto event = data->get_event_by_id(evendId);
+	auto day = data->getDayByDate(date);
+	if (!day.has_value()) {
+		return std::nullopt;
+	}
+	return Day{data, day.value()};
+}
+
+void Source::createEvent(const createEventParams &eventToCreate)
+{
+	std::optional<int> dayId = std::nullopt;
+
+	auto day = data->getDayByDate(eventToCreate.date);
+	if (!day.has_value()) {
+		day = data->insertDay({.id = generateUniqueId(), .date = eventToCreate.date});
+		dayId = day->id;
+	}
+
+	data->insertEvent({
+		.id = generateUniqueId(),
+		.dayId = day.value().id,
+		.title = eventToCreate.title,
+		.startsAt = eventToCreate.startsAt,
+		.endsAt = eventToCreate.endsAt,
+	});
+};
+
+std::optional<Event> Source::getEventById(int evendId)
+{
+	auto event = data->getEventById(evendId);
 	if (!event.has_value()) {
 		return std::nullopt;
 	}
 	return Event{data, event.value()};
 }
 
-void source::remove_event(const Event &event)
+void Source::removeEvent(const Event &event)
 {
-	data->remove_event_by_id(event.id());
+	data->removeEventById(event.id());
 }
 
-void source::remove_task(const Task &task)
+void Source::removeTask(const Task &task)
 {
-	data->remove_task_by_id(task.id());
+	data->removeTaskById(task.id());
 }
 
-std::optional<Task> source::get_task_by_id(int taskId)
+std::optional<Task> Source::getTaskById(int taskId)
 {
-	auto taskData = data->get_task_by_id(taskId);
+	auto taskData = data->getTaskById(taskId);
 	if (!taskData.has_value()) {
 		return std::nullopt;
 	}
@@ -82,55 +116,59 @@ std::optional<Task> source::get_task_by_id(int taskId)
 	return task;
 }
 
-std::vector<Task> source::get_tasks()
+std::vector<Task> Source::getTasks()
 {
-	auto tasksData = data->get_tasks();
+	auto tasksData = data->getTasks();
 	std::vector<Task> tasks;
 	std::transform(
 		tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
-		[&](const task_data &taskData) { return Task{data, taskData}; }
+		[&](const TaskData &taskData) {
+			return Task{data, taskData};
+		}
 	);
 	return tasks;
 }
 
-std::vector<Task> source::get_unscheduled_tasks()
+std::vector<Task> Source::getUnscheduledTasks()
 {
-	auto tasksData = data->get_tasks_without_date();
+	auto tasksData = data->getTasksWithoutDate();
 	std::vector<Task> tasks;
 	std::transform(
 		tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
-		[&](const task_data &taskData) { return Task{data, taskData}; }
+		[&](const TaskData &taskData) {
+			return Task{data, taskData};
+		}
 	);
 	return tasks;
 }
 
-std::string source::name() const
+std::string Source::name() const
 {
-	return _name;
+	return name_;
 }
 
-std::string source::color() const
+std::string Source::color() const
 {
-	return _color;
+	return color_;
 }
 
-void source::set_name(const std::string &name)
+void Source::setName(const std::string &name)
 {
-	_name = name;
+	name_ = name;
 }
 
-void source::set_color(const std::string &color)
+void Source::setColor(const std::string &color)
 {
-	_color = color;
+	color_ = color;
 }
 
-std::string source::type() const
+std::string Source::type() const
 {
 	// There is only 1 type for now
-	return _type;
+	return type_;
 }
 
-data_provider *source::data_provider()
+DataProvider *Source::dataProvider()
 {
 	return data;
 }
diff --git a/external/mirai-core/src/Task.cpp b/external/mirai-core/src/Task.cpp
index 6af9579..54c87ab 100644
--- a/external/mirai-core/src/Task.cpp
+++ b/external/mirai-core/src/Task.cpp
@@ -6,6 +6,7 @@
 
 #include "Task.h"
 #include "DataProvider.h"
+#include "Day.h"
 #include "utils.h"
 #include <optional>
 #include <string>
@@ -18,7 +19,7 @@ int Task::id() const
 	return task_.id;
 }
 
-int Task::source_id() const
+int Task::sourceId() const
 {
 	return data_->id;
 }
@@ -28,7 +29,7 @@ std::string Task::title() const
 	return task_.title;
 }
 
-mirai::task_state Task::state() const
+mirai::TaskState Task::state() const
 {
 	return task_.state;
 }
@@ -38,39 +39,52 @@ bool Task::checked() const
 	return task_.state == mirai::DONE;
 }
 
-bool Task::has_due_date() const
+bool Task::hasEvent() const
 {
-	return task_.due_date.has_value();
+	return task_.eventId.has_value();
 }
 
-std::optional<Date> Task::due_date() const
+bool Task::hasDate() const
 {
-	if (!task_.due_date.has_value()) {
-		return std::nullopt;
-	}
-	return task_.due_date.value();
+	return task_.dayId.has_value();
 }
 
-void Task::set_title(const std::string &newTitle)
+void Task::setTitle(const std::string &newTitle)
 {
-	data_->update_task(id(), {.title = newTitle});
+	data_->updateTask(id(), {.title = newTitle});
 }
 
-void Task::set_date(const Date &date)
+void Task::setDay(const Day &day)
 {
 	auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
-	data_->update_task(id(), {.due_date = date});
+	data_->updateTask(id(), {.dayId = day.id(), .eventId = emptyEventId});
+}
+
+void Task::setDate(const Date &date)
+{
+	auto day = data_->getDayByDate(date);
+	if (!day.has_value()) {
+		day = data_->insertDay({.id = generateUniqueId(), .date = date});
+	}
+	auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
+	data_->updateTask(id(), {.dayId = day.value().id, .eventId = emptyEventId});
 }
 
 void Task::unschedule()
 {
 	auto emptyId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
-	data_->update_task(id(), {.due_date = std::nullopt});
+	data_->updateTask(id(), {.dayId = emptyId, .eventId = emptyId});
 }
 
-void Task::set_checked(bool checked)
+void Task::setEvent(const Event &event)
 {
-	data_->update_task(id(), {.state = checked ? DONE : TODO});
+	auto emptyDayId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
+	data_->updateTask(id(), {.dayId = emptyDayId, .eventId = event.id()});
+}
+
+void Task::setChecked(bool checked)
+{
+	data_->updateTask(id(), {.state = checked ? DONE : TODO});
 }
 
 } // namespace mirai
diff --git a/external/mirai-core/src/View.cpp b/external/mirai-core/src/View.cpp
new file mode 100644
index 0000000..30471d3
--- /dev/null
+++ b/external/mirai-core/src/View.cpp
@@ -0,0 +1,165 @@
+/*
+ * Mirai. Copyright (C) 2024 Vyn
+ * This file is licensed under version 3 of the GNU General Public License (GPL-3.0-only)
+ * The license can be found in the LICENSE file or at https://www.gnu.org/licenses/gpl-3.0.txt
+ */
+
+#include "View.h"
+#include "utils.h"
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include <ranges>
+
+namespace mirai
+{
+
+View::View(Mirai *mirai) : mirai_(mirai)
+{
+}
+
+void View::hideCompletedTasks(bool hide)
+{
+	shouldHideCompletedTasks_ = hide;
+}
+
+bool View::shouldHideCompletedTasks() const
+{
+	return shouldHideCompletedTasks_;
+}
+
+std::vector<Date> View::getDates()
+{
+	std::vector<Date> datesVector;
+	for (auto &date : dates) {
+		datesVector.push_back(date.first);
+	}
+	return datesVector;
+}
+
+std::vector<Task> View::getTasksForDate(const Date &date)
+{
+	return dates.at(date).tasks;
+}
+
+std::vector<Event> View::getEventsForDate(const Date &date)
+{
+	if (!dates.contains(date)) {
+		return {};
+	}
+	return dates.at(date).events;
+}
+
+std::vector<Task> View::getUnscheduledTasks()
+{
+	return unscheduledTasks_;
+}
+
+void View::update()
+{
+	dates.clear();
+	unscheduledTasks_.clear();
+
+	auto todayDate = Date(std::chrono::system_clock::now());
+
+	for (int sourceId : sourcesIds_) {
+		Source *source = mirai_->getSourceById(sourceId);
+		for (auto day : source->getDays()) {
+			// day's tasks
+			auto sourceTasks = day.tasks() | std::ranges::views::filter([&](const Task &task) {
+								   if (day.date() >= todayDate) {
+									   return true;
+								   }
+								   if (shouldHideCompletedTasks()) {
+									   return task.checked() == false;
+								   }
+								   return true;
+							   });
+			if (day.date() >= todayDate || std::ranges::distance(sourceTasks) > 0) {
+
+				if (!dates.contains(day.date())) {
+					dates.insert_or_assign(day.date(), DateView{});
+				}
+				auto &tasks = dates.at(day.date()).tasks;
+				tasks.insert(tasks.end(), sourceTasks.begin(), sourceTasks.end());
+			}
+
+			// day's events
+			auto sourceEvents =
+				day.events() | std::ranges::views::filter([&](const Event &event) {
+					return (!shouldHideCompletedTasks() || day.date() >= todayDate) ||
+						   findFirst(event.queryTasks(), [&](const Task &task) {
+							   return task.checked() == false;
+						   }).has_value();
+				});
+
+			if (day.date() >= todayDate || std::ranges::distance(sourceEvents) > 0) {
+				if (!dates.contains(day.date())) {
+					dates.insert_or_assign(day.date(), DateView{});
+				}
+				auto &events = dates.at(day.date()).events;
+				events.insert(events.end(), sourceEvents.begin(), sourceEvents.end());
+			}
+		}
+		// unscheduled tasks
+		auto tasks = source->getUnscheduledTasks();
+		unscheduledTasks_.insert(unscheduledTasks_.end(), tasks.begin(), tasks.end());
+	}
+
+	for (auto &date : dates) {
+		auto &events = date.second.events;
+		std::sort(events.begin(), events.end(), [](const Event &a, const Event &b) {
+			return a.startsAt() < b.startsAt();
+		});
+	}
+}
+
+void View::removeSources()
+{
+	sourcesIds_.clear();
+}
+
+void View::addSource(const Source &source)
+{
+	sourcesIds_.push_back(source.id);
+}
+
+void View::setSources(const std::vector<Source> &sources)
+{
+	sourcesIds_.clear();
+	std::transform(
+		sources.begin(), sources.end(), std::back_inserter(sourcesIds_),
+		[](const Source &source) {
+			return source.id;
+		}
+	);
+}
+
+void View::setAllSources()
+{
+	const auto &sources = mirai_->getSources();
+	sourcesIds_.clear();
+	std::transform(
+		sources.begin(), sources.end(), std::back_inserter(sourcesIds_),
+		[](const std::unique_ptr<Source> &source) {
+			return source->id;
+		}
+	);
+}
+
+bool View::isSourceSelected(const Source &source) const
+{
+	for (auto &sourceId : sourcesIds_) {
+		if (sourceId == source.id) {
+			return true;
+		}
+	}
+	return false;
+}
+
+size_t View::activeSourceCount() const
+{
+	return sourcesIds_.size();
+}
+
+} // namespace mirai
diff --git a/external/mirai-core/src/utils.cpp b/external/mirai-core/src/utils.cpp
index 2e929fa..8f5053f 100644
--- a/external/mirai-core/src/utils.cpp
+++ b/external/mirai-core/src/utils.cpp
@@ -39,7 +39,7 @@ bool isDate(const std::string &dateStr)
 	return true;
 }
 
-int generate_unique_id()
+int generateUniqueId()
 {
 	static int nextId = 0;
 	return nextId++;
diff --git a/src/components/Calendar.slint b/src/components/Calendar.slint
index f667507..4eb1404 100644
--- a/src/components/Calendar.slint
+++ b/src/components/Calendar.slint
@@ -1,10 +1,10 @@
 import { ScrollView, Date, Time } from "std-widgets.slint";
 import { VCheckBox, VButton, VActionButton, Svg, VTag, VPopupIconMenu, VText, Palette } from "@selenite";
 import { Utils } from "../shared/Utils.slint";
-import { AppModels, CalendarViewDate, CalendarDateDisplayFormat  } from "../shared/Models.slint";
+import { AppModels, CalendarDay, CalendarDateDisplayFormat  } from "../shared/Models.slint";
 
 export component Calendar inherits Rectangle {
-	in property<[CalendarViewDate]> days;
+	in property<[CalendarDay]> days;
 	in property <CalendarDateDisplayFormat> format;
 	in property <Date> current-date;
 	in property <Time> current-time;
@@ -17,6 +17,8 @@ export component Calendar inherits Rectangle {
 
 	callback delete-event-request(source-id: int, event-id: int);
 
+	
+
 	HorizontalLayout {
 		Rectangle {
 			//background: red;
@@ -92,20 +94,20 @@ export component Calendar inherits Rectangle {
 						Rectangle {
 							width: 100%;
 							height: 100%;
-							background: AppModels.get-source-color-from-id-as-color(event.source-id);
+							background: AppModels.get-source-color-from-id-as-color(event.sourceId);
 							opacity: 0.05;
 						}
 						background: Palette.card-background;
 						border-radius: 4px;
 						x: 8px;
 						width: parent.width - 16px;
-						y: day-start-y + hour-spacing * event.starts_at.hour;
-						height: hour-spacing * (event.ends_at.hour - event.starts_at.hour) - 2px;
+						y: day-start-y + hour-spacing * event.startsAt.hour;
+						height: hour-spacing * (event.endsAt.hour - event.startsAt.hour) - 2px;
 						clip: true;
 						HorizontalLayout {
 							Rectangle {
 								width: 4px;
-								background: AppModels.get-source-color-from-id-as-color(event.source-id);
+								background: AppModels.get-source-color-from-id-as-color(event.sourceId);
 							}
 							VerticalLayout {
 								padding: 16px;
@@ -136,7 +138,7 @@ export component Calendar inherits Rectangle {
 								icon-size: 1.5rem;
 								border-radius: 0;
 								clicked => {
-									delete-event-request(event.source-id, event.id);
+									delete-event-request(event.sourceId, event.id);
 								}
 							}
 						}
diff --git a/src/components/CreateTaskOrEvent.slint b/src/components/CreateTaskOrEvent.slint
index b70aed8..bda2791 100644
--- a/src/components/CreateTaskOrEvent.slint
+++ b/src/components/CreateTaskOrEvent.slint
@@ -39,7 +39,7 @@ export component CreateTaskOrEvent inherits Rectangle {
 			newTaskTitleInput := VTextInput {
 				placeholder: "Enter new task";
 			 	started-writting() => {
-					sourceInput.current-index = 0;
+					sourceInput.current-index = AppModels.default-source-index;
 			 	}
 				accepted => { accepted() }
 			}
diff --git a/src/components/EventGroup.slint b/src/components/EventGroup.slint
new file mode 100644
index 0000000..ea698c7
--- /dev/null
+++ b/src/components/EventGroup.slint
@@ -0,0 +1,128 @@
+import { Event } from "../shared/Models.slint";
+import { ScrollView } from "std-widgets.slint";
+import { VCheckBox, VTextInput, VButton, VActionButton, Svg, VTag, VPopupIconMenu, VText, Palette } from "@selenite";
+import { TaskLine } from "./TaskLine.slint";
+import { Utils } from "../shared/Utils.slint";
+
+export struct EventGroupAddTask {
+	title: string
+}
+
+export component EventGroup {
+	in property<Event> event;
+	private property <bool> show-add-task: false;
+	private property <bool> edit-name: false;
+
+	callback add-task(EventGroupAddTask);
+	callback edit-task(int, EventGroupAddTask);
+	callback delete-task(int);
+	callback delete();
+	callback edit(EventGroupAddTask);
+	callback toggle-check-task(int);
+
+	eventPopup := VPopupIconMenu {
+		VActionButton {
+			icon-svg: Svg.plus;
+			icon-colorize: Colors.greenyellow;
+			icon-size: 1.5rem;
+			border-radius: 0;
+			clicked => { 
+				root.show-add-task = true;
+			}
+		}
+		VActionButton {
+			icon-svg: Svg.pen;
+			icon-colorize: Colors.grey;
+			icon-size: 1.5rem;
+			border-radius: 0;
+			clicked => { edit-name = true; }
+		}
+
+		VActionButton {
+			icon-svg: Svg.trash;
+			icon-colorize: Colors.pink;
+			icon-size: 1.5rem;
+			border-radius: 0;
+			clicked => { root.delete() }
+		}
+	}
+
+	ta := TouchArea {
+		pointer-event(e) => { 
+			if (e.button == PointerEventButton.right && e.kind == PointerEventKind.up) {
+				eventPopup.show(ta.mouse-x, ta.mouse-y); 
+			}
+		}
+	}
+
+	HorizontalLayout {
+		VerticalLayout {
+			spacing: 4px;
+			VText {
+				text: Utils.time-to-string(event.startsAt);
+				horizontal-alignment: center;
+				color: Palette.accent;
+			}
+			HorizontalLayout {
+				alignment: center;
+				Rectangle {
+					width: 2px;
+					background: Palette.accent;
+				}
+			}
+			VText {
+				text: Utils.time-to-string(event.endsAt);
+				color: Palette.accent;
+				font-size: 0.9rem;
+				horizontal-alignment: center;
+			}
+		}
+		VerticalLayout {
+			horizontal-stretch: 1;
+			padding: 16px;
+			padding-top: 32px;
+			padding-bottom: 32px;
+			padding-right: 0px;
+			if !edit-name : VText {
+				text: event.title;
+				font-size: 1.1rem;
+			}
+			if edit-name : title := VTextInput {
+				text: event.title;
+				accepted => { 
+					root.edit({
+						title: title.text
+					});
+					root.edit-name = false;
+				}
+			}
+			for task[taskIndex] in event.tasks: VerticalLayout {
+				padding-top: taskIndex == 0 ? 16px : 0px;
+				padding-bottom: 8px;
+				TaskLine {
+					title: task.title;
+					checked: task.checked;
+					delete => { 
+						root.delete-task(task.id)
+					}
+					toggle-check => {
+						root.toggle-check-task(task.id)
+					}
+					edited(data) => {
+						root.edit-task(task.id, {
+							title: data.title
+						});
+					}
+				}
+			}
+			if show-add-task : taskInput := VTextInput {
+				accepted => { 
+					root.add-task({
+						title: taskInput.text
+					});
+					root.show-add-task = false;
+				}
+			}
+		}
+	}
+}
diff --git a/src/shared/Actions.slint b/src/shared/Actions.slint
index f0f003e..721168e 100644
--- a/src/shared/Actions.slint
+++ b/src/shared/Actions.slint
@@ -1,4 +1,5 @@
 import { Date, Time } from "std-widgets.slint";
+import { CalendarDay } from "./Models.slint";
 
 export struct NewTaskData {
 	sourceId: int,
diff --git a/src/shared/Models.slint b/src/shared/Models.slint
index ba26e08..e044f22 100644
--- a/src/shared/Models.slint
+++ b/src/shared/Models.slint
@@ -1,76 +1,68 @@
 import { Date, Time } from "std-widgets.slint";
 
-export struct TasksViewTask {
-	id: int,
-	source-id: int,
-	title: string,
-	checked: bool
-}
-
-export struct TasksViewSource {
+export struct Source {
 	id: int,
 	name: string,
-	color: color,
-	tasks: [TasksViewTask]
+	selected: bool,
+	path: string
 }
 
-export struct TasksViewDate {
-	due-date: Date,
-	no-date: bool,
-	is-late: bool,
-	sources: [TasksViewSource]
+export struct TaskData {
+	sourceId: int,
+	eventId: int,
+	id: int,
+    title: string,
+	date: Date,
+    checked: bool,
 }
 
-export struct TasksView {
-	dates: [TasksViewDate],
-	sources: [string]
-}
-
-export struct CalendarViewEvent {
-	source-id: int,
+export struct Event {
+	sourceId: int,
 	id: int,
 	title: string,
-	starts-at: Time,
-	ends-at: Time
+	startsAt: Time,
+	endsAt: Time,
+	tasks: [TaskData],
 }
 
-export struct CalendarViewDate {
-	events: [CalendarViewEvent],
+export struct Day {
+	sourceId: int,
+	id: int,
+	date: Date,
+	events: [Event],
+	tasks: [TaskData],
+	isLate: bool,
+	isToday: bool,
+	relativeDaysDiff: int
+}
+
+export struct CalendarDayEvent {
+	sourceId: int,
+	id: int,
+	title: string,
+	startsAt: Time,
+	endsAt: Time
+}
+
+export struct CalendarDay {
+	events: [CalendarDayEvent],
 	date: Date,
 	header: string,
 }
 
-export struct CalendarView {
-	dates: [CalendarViewDate]
-}
-
-export struct SidebarViewSources {
-	id: int,
-	name: string,
-	color: color,
-	active: bool
-}
-
-export enum SidebarViewActiveTab {
-	tasks,
-	calendar
-}
-
-export struct SidebarView {
-	sources: [SidebarViewSources],
-	active-view: SidebarViewActiveTab,
-	all-active: bool
-}
-
 export enum CalendarDateDisplayFormat {
 	Relative,
 	Normal
 }
 
 export global AppModels  {
-    in-out property<SidebarView> sidebar-view;
-	in-out property<TasksView> tasks-view;
-	in-out property<CalendarView> calendar-view;
+    in-out property<[Source]> sources-selected; 
+    in-out property<int> default-source-index;
+    in-out property<[string]> sources;
+	in-out property<bool> no-source-selected;
+	in-out property<[Day]> days;
+	in-out property<[CalendarDay]> calendar;
+	in-out property<[TaskData]> unscheduled-tasks;
 
 	callback get-source-id-from-name(string) -> int;
 	pure callback get-source-name-from-id(int) -> string;
diff --git a/src/view.h b/src/view.h
deleted file mode 100644
index 30ceb45..0000000
--- a/src/view.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "DataProvider.h"
-#include "DateTime.h"
-#include <vector>
-
-struct source_group {
-	int source_id;
-	std::vector<mirai::event_data> events;
-	std::vector<mirai::task_data> tasks;
-};
-
-struct day_group {
-	mirai::Date date;
-	source_group sources;
-};
-
-std::vector<day_group>
-group_by_day(std::vector<mirai::event_data> events, std::vector<mirai::task_data> tasks)
-{
-	std::vector<day_group> days;
-
-	// todo
-
-	return days;
-}
diff --git a/src/windows/AppWindow/AppWindow.cpp b/src/windows/AppWindow/AppWindow.cpp
index e35a0ba..19ecdfb 100644
--- a/src/windows/AppWindow/AppWindow.cpp
+++ b/src/windows/AppWindow/AppWindow.cpp
@@ -8,40 +8,37 @@
 #include "../../SeleniteSetup.h"
 #include "../../shared/Utils.h"
 #include "mirai-core/DateTime.h"
-#include "mirai-core/Event.h"
+#include "mirai-core/Day.h"
 #include "mirai-core/MarkdownDataProvider.h"
 #include "mirai-core/Mirai.h"
-#include "mirai-core/Source.h"
 #include "selenite/palette.h"
 #include "slint_color.h"
-#include "slint_models.h"
 #include "slint_string.h"
 #include "ui.h"
-#include <algorithm>
 #include <bits/chrono.h>
 #include <cassert>
 #include <chrono>
 #include <cstdlib>
 #include <iostream>
-#include <iterator>
 #include <memory>
 #include <optional>
 #include <print>
-#include <ranges>
 #include <string>
 #include <string_view>
 #include <vector>
 
-AppWindow::AppWindow(mirai::Mirai *miraiInstance) : miraiInstance_(miraiInstance)
+AppWindow::AppWindow(mirai::Mirai *miraiInstance)
+	: miraiInstance_(miraiInstance), view_(miraiInstance)
 {
-	_sidebar_view = ui::SidebarView();
-	_calendar_view = ui::CalendarView();
-	_tasks_view = ui::TasksView();
-	/*auto sourcesNames = std::make_shared<slint::MapModel<ui::Source, slint::SharedString>>(*/
-	/*sources_, [&](const ui::Source &a) {*/
-	/*return a.name;*/
-	/*}*/
-	/*);*/
+	sources_ = std::make_shared<slint::VectorModel<ui::Source>>();
+	days_ = std::make_shared<slint::VectorModel<ui::Day>>();
+	calendar_ = std::make_shared<slint::VectorModel<ui::CalendarDay>>();
+	unscheduledTasks_ = std::make_shared<slint::VectorModel<ui::TaskData>>();
+	auto sourcesNames = std::make_shared<slint::MapModel<ui::Source, slint::SharedString>>(
+		sources_, [&](const ui::Source &a) {
+			return a.name;
+		}
+	);
 
 	const auto palettePath = std::string(getenv("HOME")) + "/.config/evalyte/theme.json";
 	const auto palette = selenite::parseJson(palettePath);
@@ -52,14 +49,13 @@ AppWindow::AppWindow(mirai::Mirai *miraiInstance) : miraiInstance_(miraiInstance
 
 	bindSlintUtils(mainWindow_->global<ui::Utils>());
 
-	models().set_sidebar_view(_sidebar_view);
-	models().set_calendar_view(_calendar_view);
-	models().set_tasks_view(_tasks_view);
+	models().set_sources(sourcesNames);
+	models().set_sources_selected(sources_);
+	models().set_days(days_);
+	models().set_calendar(calendar_);
 
-	show_all_sources();
-	update_views();
-	/*view_.setAllSources();*/
-	/*view_.update();*/
+	view_.setAllSources();
+	view_.update();
 
 	reloadSources();
 	reloadTasks();
@@ -118,49 +114,53 @@ void AppWindow::setupCallbacks()
 	models().on_get_source_path_from_id([&](int sourceId) {
 		auto source = miraiInstance_->getSourceById(sourceId);
 		assert(source);
-		mirai::markdown_data_provider *sourceProvider =
-			dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());
+		mirai::MarkdownDataProvider *sourceProvider =
+			dynamic_cast<mirai::MarkdownDataProvider *>(source->dataProvider());
 		return slint::SharedString(sourceProvider->path());
 	});
 
-	miraiInstance_->onSourceAdded([&](mirai::source *source) { refreshModels(); });
-	miraiInstance_->onSourceEdited([&](mirai::source *source) { refreshModels(); });
-	miraiInstance_->onSourceDeleted([&](int id) { refreshModels(); });
+	miraiInstance_->onSourceAdded([&](mirai::Source *source) {
+		refreshModels();
+	});
+	miraiInstance_->onSourceEdited([&](mirai::Source *source) {
+		refreshModels();
+	});
+	miraiInstance_->onSourceDeleted([&](int id) {
+		refreshModels();
+	});
 
 	actions().on_task_clicked([&](int sourceId, int taskId) {
 		auto source = miraiInstance_->getSourceById(sourceId);
 		assert(source);
-		auto task = source->get_task_by_id(taskId);
+		auto task = source->getTaskById(taskId);
 		assert(task);
-		task->set_checked(!task->checked());
+		if (!task->checked() && !task->hasDate() && !task->hasEvent()) {
+			task->setDate(mirai::Date(mirai::Date(std::chrono::system_clock::now())));
+		}
+		task->setChecked(!task->checked());
 		miraiInstance_->save();
-		update_views();
-		// view_.update();
+		view_.update();
 		reloadTasks();
 	});
 
 	actions().on_source_clicked([&](int index) {
 		// index with value -1 is equal to no selection, aka "All"
 		if (index == -1) {
-			show_all_sources();
-			// view_.setAllSources();
+			view_.setAllSources();
 		} else {
-			hide_all_sources();
-			// view_.removeSources();
-			const mirai::source *source = miraiInstance_->getSourceById(index);
-			show_source(*source);
-			// view_.addSource(*source);
+			view_.removeSources();
+			const mirai::Source *source = miraiInstance_->getSourceById(index);
+			view_.addSource(*source);
 		}
-		// models().set_default_source_index(index == -1 ? 0 : index);
-		update_views();
-		// view_.update();
+		models().set_default_source_index(index == -1 ? 0 : index);
+		view_.update();
 		reloadSources();
 		reloadTasks();
 	});
 
 	actions().on_add_source([&](slint::SharedString name, slint::SharedString path) {
-		std::unique_ptr<mirai::data_provider> file =
-			std::make_unique<mirai::markdown_data_provider>(std::string(path));
+		std::unique_ptr<mirai::DataProvider> file =
+			std::make_unique<mirai::MarkdownDataProvider>(std::string(path));
 		miraiInstance_->addSource(std::string(name), "FileSystemMarkdown", std::move(file));
 	});
 
@@ -174,39 +174,39 @@ void AppWindow::setupCallbacks()
 	actions().on_delete_task_clicked([&](int sourceId, int taskId) {
 		auto source = miraiInstance_->getSourceById(sourceId);
 		assert(source);
-		auto task = source->get_task_by_id(taskId);
+		auto task = source->getTaskById(taskId);
 		assert(task);
-		source->remove_task(*task);
+		source->removeTask(*task);
 		miraiInstance_->save();
-		// view_.update();
-		update_views();
+		view_.update();
 		reloadTasks();
 	});
 
 	actions().on_toggle_show_completed_tasks([&] {
-		// view_.hideCompletedTasks(!view_.shouldHideCompletedTasks());
-		if (should_hide_completed_tasks()) {
-			show_completed_tasks();
-		} else {
-			hide_completed_tasks();
-		}
-		// view_.update();
-		update_views();
+		view_.hideCompletedTasks(!view_.shouldHideCompletedTasks());
+		view_.update();
 		reloadTasks();
 	});
 
 	actions().on_save_task([&](ui::SaveTaskData newTaskData) {
 		auto source = miraiInstance_->getSourceById(newTaskData.sourceId);
 		assert(source);
-		auto task = source->get_task_by_id(newTaskData.id);
+		auto task = source->getTaskById(newTaskData.id);
 		assert(task.has_value());
 		const mirai::Date &date = SlintDateToMiraiDate(newTaskData.date);
-		// const auto dayOpt = source->get_day_by_date(date);
-		task->set_title(std::string(newTaskData.title));
+		const auto dayOpt = source->getDayByDate(date);
+		task->setTitle(std::string(newTaskData.title));
+
+		if (!task.value().hasEvent() && date.year != 0) {
+			task->setDate(date);
+		}
+
+		if (!task.value().hasEvent() && date.year == 0) {
+			task->unschedule();
+		}
 
 		miraiInstance_->save();
-		// view_.update();
-		update_views();
+		view_.update();
 		reloadTasks();
 	});
 
@@ -219,47 +219,45 @@ void AppWindow::setupCallbacks()
 
 		std::optional<mirai::Event> event = std::nullopt;
 		if (newTaskData.eventId >= 0) {
-			event = source->get_event_by_id(newTaskData.eventId);
+			event = source->getEventById(newTaskData.eventId);
 		}
 
-		source->create_task({
+		source->createTask({
 			.title = std::string(newTaskData.title),
-			.due_date = date,
+			.event = event,
+			.date = date,
 		});
 
 		miraiInstance_->save();
-		// view_.update();
-		update_views();
+		view_.update();
 		reloadTasks();
 	});
 
 	actions().on_delete_event([&](int sourceId, int eventId) {
 		auto source = miraiInstance_->getSourceById(sourceId);
 		assert(source);
-		auto event = source->get_event_by_id(eventId);
+		auto event = source->getEventById(eventId);
 		assert(event.has_value());
-		source->remove_event(event.value());
+		source->removeEvent(event.value());
 		miraiInstance_->save();
-		// view_.update();
-		update_views();
+		view_.update();
 		reloadTasks();
 	});
 
 	actions().on_create_event([&](ui::CreateEventParams newEventParams) {
 		const ui::Date &date = newEventParams.date;
 		const std::string dateStr = SlintDateToStdString(date);
-		// const auto sourceId = models().get_default_source_index();
-		// auto source = miraiInstance_->getSourceById(sourceId == -1 ? 0 : sourceId);
+		const auto sourceId = models().get_default_source_index();
+		auto source = miraiInstance_->getSourceById(sourceId == -1 ? 0 : sourceId);
 
-		/* source->create_event({*/
-		/*.title = std::string(newEventParams.title),*/
-		/*.date = SlintDateToMiraiDate(newEventParams.date),*/
-		/*.starts_at = SlintTimeToMiraiTime(newEventParams.startsAt),*/
-		/*.ends_at = SlintTimeToMiraiTime(newEventParams.endsAt),*/
-		/*});*/
+		source->createEvent({
+			.title = std::string(newEventParams.title),
+			.date = SlintDateToMiraiDate(newEventParams.date),
+			.startsAt = SlintTimeToMiraiTime(newEventParams.startsAt),
+			.endsAt = SlintTimeToMiraiTime(newEventParams.endsAt),
+		});
 		miraiInstance_->save();
-		// view_.update();
-		update_views();
+		view_.update();
 		reloadTasks();
 	});
 }
@@ -276,410 +274,157 @@ stdToSlintStringVector(const std::vector<std::string> &stdVector)
 
 void AppWindow::reloadTasks()
 {
-	/* days_->clear();*/
-	/*if (miraiInstance_->getSources().size() == 0) {*/
-	/*return;*/
-	/*}*/
-	/*auto todayDate = mirai::Date(std::chrono::system_clock::now());*/
-	/*auto dates = view_.getDates();*/
-	/*auto slintDays = std::make_shared<slint::VectorModel<ui::Day>>();*/
-	/*for (int dayIndex = 0; dayIndex < dates.size(); ++dayIndex) {*/
-	/*auto &currentDate = dates.at(dayIndex);*/
-	/*auto slintEvents = std::make_shared<slint::VectorModel<ui::Event>>();*/
-	/*auto slintDayTasks = std::make_shared<slint::VectorModel<ui::TaskData>>();*/
-	/*auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(*/
-	/*std::chrono::sys_days(currentDate.toStdChrono()) -*/
-	/*std::chrono::sys_days(todayDate.toStdChrono())*/
-	/*)*/
-	/*.count();*/
-	/*slintDays->push_back(*/
-	/*ui::Day{*/
-	/*.date = MiraiDateToSlintDate(currentDate),*/
-	/*.events = slintEvents,*/
-	/*.tasks = slintDayTasks,*/
-	/*.isLate = currentDate < todayDate,*/
-	/*.isToday = currentDate == todayDate,*/
-	/*.relativeDaysDiff = static_cast<int>(relativeDaysDiff)*/
-	/*}*/
-	/*);*/
-	/*Day's tasks*/
-	/*const std::vector<mirai::Task> tasksForDate = view_.getTasksForDate(currentDate);*/
-	/*for (int taskIndex = 0; taskIndex < tasksForDate.size(); ++taskIndex) {*/
-	/*auto &task = tasksForDate.at(taskIndex);*/
-	/*slintDayTasks->push_back({*/
-	/*.sourceId = task.sourceId(),*/
-	/*.eventId = -1,*/
-	/*.id = task.id(),*/
-	/*.title = slint::SharedString(task.title()),*/
-	/*.checked = task.checked(),*/
-	/*});*/
-	/*}*/
-
-	/*Day's events*/
-	/*const std::vector<mirai::Event> eventsForDate = view_.getEventsForDate(currentDate);*/
-	/*for (int eventIndex = 0; eventIndex < eventsForDate.size(); ++eventIndex) {*/
-	/*auto &currentEvent = eventsForDate.at(eventIndex);*/
-	/*auto slintTasks = std::make_shared<slint::VectorModel<ui::TaskData>>();*/
-	/*slintEvents->push_back(*/
-	/*ui::Event{*/
-	/*.sourceId = currentEvent.source_id(),*/
-	/*.id = currentEvent.id(),*/
-	/*.title = slint::SharedString(currentEvent.title()),*/
-	/*.startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),*/
-	/*.endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),*/
-	/*.tasks = slintTasks,*/
-	/*}*/
-	/*);*/
-	/*auto eventTasks = currentEvent.queryTasks();*/
-	/*for (int taskIndex = 0; taskIndex < eventTasks.size(); ++taskIndex) {*/
-	/*auto &task = eventTasks.at(taskIndex);*/
-	/*slintTasks->push_back({*/
-	/*.sourceId = task.sourceId(),*/
-	/*.eventId = currentEvent.id(),*/
-	/*.id = task.id(),*/
-	/*.title = slint::SharedString(task.title()),*/
-	/*.checked = task.checked(),*/
-	/*});*/
-	/*}*/
-	/*}*/
-	/*}*/
-	/*days_ = slintDays;*/
-	/*models().set_days(days_);*/
-
-	/*auto unscheduledTasksView = view_.getUnscheduledTasks();*/
-	/*unscheduledTasks_->clear();*/
-	/*for (int taskIndex = 0; taskIndex < unscheduledTasksView.size(); ++taskIndex) {*/
-	/*auto &task = unscheduledTasksView.at(taskIndex);*/
-	/*const auto &source = miraiInstance_->getSourceById(task.sourceId());*/
-	/*std::println("request name for source id {} : {}", task.sourceId(), source->name());*/
-	/*unscheduledTasks_->push_back({*/
-	/*.sourceId = task.sourceId(),*/
-	/*.eventId = -1,*/
-	/*.id = task.id(),*/
-	/*.title = slint::SharedString(task.title()),*/
-	/*.checked = task.checked(),*/
-	/*});*/
-	/*}*/
-	/*models().set_unscheduled_tasks(unscheduledTasks_);*/
-
-	/*calendar_->clear();*/
-	/*for (int dayIndex = 0; dayIndex < 7; ++dayIndex) {*/
-	/*std::chrono::year_month_day nextDate =*/
-	/*std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now()) +*/
-	/*std::chrono::days{dayIndex};*/
-	/*auto currentDate = mirai::Date{nextDate};*/
-	/*auto events = view_.getEventsForDate(currentDate);*/
-	/*auto slintEvents = std::make_shared<slint::VectorModel<ui::CalendarDayEvent>>();*/
-	/*auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(*/
-	/*std::chrono::sys_days(currentDate.toStdChrono()) -*/
-	/*std::chrono::sys_days(todayDate.toStdChrono())*/
-	/*)*/
-	/*.count();*/
-	/*if (relativeDaysDiff < 0 || relativeDaysDiff >= 7) {*/
-	/*continue;*/
-	/*}*/
-	/*const std::vector<mirai::Event> eventsForDate = view_.getEventsForDate(currentDate);*/
-	/*for (int eventIndex = 0; eventIndex < eventsForDate.size(); ++eventIndex) {*/
-	/*auto &currentEvent = eventsForDate.at(eventIndex);*/
-	/*slintEvents->push_back(*/
-	/*ui::CalendarDayEvent{*/
-	/*.sourceId = currentEvent.source_id(),*/
-	/*.id = currentEvent.id(),*/
-	/*.title = slint::SharedString(currentEvent.title()),*/
-	/*.startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),*/
-	/*.endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),*/
-	/*}*/
-	/*);*/
-	/*}*/
-
-	/*auto calendarDay = ui::CalendarDay{*/
-	/*.events = slintEvents,*/
-	/*.date = MiraiDateToSlintDate(currentDate),*/
-	/*.header = slint::SharedString(*/
-	/*capitalize(formatDateRelative(MiraiDateToSlintDate(currentDate)))*/
-	/*)*/
-	/*};*/
-	/*calendar_->push_back(calendarDay);*/
-	/*}*/
-}
-
-void AppWindow::reloadSources()
-{
-	/*sources_->clear();*/
-	/*bool noSourceSelected = miraiInstance_->getSources().size() == view_.activeSourceCount();*/
-	/*for (const auto &source : miraiInstance_->getSources()) {*/
-	/*bool isSourceSelected = view_.isSourceSelected(*source);*/
-	/*mirai::markdown_data_provider *sourceProvider =*/
-	/*dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());*/
-	/*sources_->push_back(*/
-	/*{.id = source->id,*/
-	/*.name = slint::SharedString(source->name()),*/
-	/*.selected = isSourceSelected && !noSourceSelected,*/
-	/*.path = slint::SharedString(sourceProvider->path())}*/
-	/*);*/
-	/*}*/
-	/*models().set_no_source_selected(noSourceSelected);*/
-}
-
-void AppWindow::refreshModels()
-{
-	show_all_sources();
-	update_views();
-}
-
-void AppWindow::update_views()
-{
-	update_sidebar_view();
-	update_calendar_view();
-	update_tasks_view();
-}
-
-void AppWindow::update_sidebar_view()
-{
-	const auto &sources = miraiInstance_->getSources();
-
-	auto new_sources = std::make_shared<slint::VectorModel<ui::SidebarViewSources>>();
-	std::println("sources");
-	for (auto &source : sources) {
-		std::println("source: {}", source->name());
-		mirai::markdown_data_provider *sourceProvider =
-			dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());
-
-		new_sources->push_back(
-			{.id = source->id, .name = slint::SharedString(source->name()), .active = false}
-		);
+	days_->clear();
+	if (miraiInstance_->getSources().size() == 0) {
+		return;
 	}
-
-	_sidebar_view.sources = new_sources;
-	_sidebar_view.all_active = true; // TESTING
-	_sidebar_view.active_view = ui::SidebarViewActiveTab::Calendar;
-	models().set_sidebar_view(_sidebar_view);
-}
-
-std::vector<mirai::Event>
-get_all_events_from_sources(std::vector<std::unique_ptr<mirai::source>> &sources)
-{
-	std::vector<mirai::Event> all_events;
-	for (auto &source : sources) {
-		const auto &events = source->get_events();
-		all_events.insert(all_events.end(), events.begin(), events.end());
-	}
-	return all_events;
-}
-
-std::vector<mirai::Event>
-get_events_for_date(const std::vector<mirai::Event> &events, const mirai::Date &date)
-{
-	auto filtered_events = events | std::ranges::views::filter([&](const mirai::Event &event) {
-							   return event.date() == date;
-						   });
-	return std::ranges::to<std::vector>(filtered_events);
-}
-
-void AppWindow::update_calendar_view()
-{
-	auto today = mirai::Date(std::chrono::system_clock::now());
-	auto new_slint_dates = std::make_shared<slint::VectorModel<ui::CalendarViewDate>>();
-
-	auto &sources = miraiInstance_->getSources();
-	auto all_events = get_all_events_from_sources(sources);
-
-	for (int day_index = 0; day_index < 7; ++day_index) {
-		std::chrono::year_month_day next_date =
-			std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now())
-			+ std::chrono::days{day_index};
-		auto current_date = mirai::Date{next_date};
-		auto new_slint_events = std::make_shared<slint::VectorModel<ui::CalendarViewEvent>>();
-		auto relative_days_diff = std::chrono::duration_cast<std::chrono::days>(
-									  std::chrono::sys_days(current_date.toStdChrono())
-									  - std::chrono::sys_days(today.toStdChrono())
+	auto todayDate = mirai::Date(std::chrono::system_clock::now());
+	auto dates = view_.getDates();
+	auto slintDays = std::make_shared<slint::VectorModel<ui::Day>>();
+	for (int dayIndex = 0; dayIndex < dates.size(); ++dayIndex) {
+		auto &currentDate = dates.at(dayIndex);
+		auto slintEvents = std::make_shared<slint::VectorModel<ui::Event>>();
+		auto slintDayTasks = std::make_shared<slint::VectorModel<ui::TaskData>>();
+		auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(
+									std::chrono::sys_days(currentDate.toStdChrono()) -
+									std::chrono::sys_days(todayDate.toStdChrono())
 		)
-									  .count();
-		if (relative_days_diff < 0 || relative_days_diff >= 7) {
+									.count();
+		slintDays->push_back(
+			ui::Day{
+				.date = MiraiDateToSlintDate(currentDate),
+				.events = slintEvents,
+				.tasks = slintDayTasks,
+				.isLate = currentDate < todayDate,
+				.isToday = currentDate == todayDate,
+				.relativeDaysDiff = static_cast<int>(relativeDaysDiff)
+			}
+		);
+		// Day's tasks
+		const std::vector<mirai::Task> tasksForDate = view_.getTasksForDate(currentDate);
+		for (int taskIndex = 0; taskIndex < tasksForDate.size(); ++taskIndex) {
+			auto &task = tasksForDate.at(taskIndex);
+			slintDayTasks->push_back({
+				.sourceId = task.sourceId(),
+				.eventId = -1,
+				.id = task.id(),
+				.title = slint::SharedString(task.title()),
+				.checked = task.checked(),
+			});
+		}
+
+		// Day's events
+		const std::vector<mirai::Event> eventsForDate = view_.getEventsForDate(currentDate);
+		for (int eventIndex = 0; eventIndex < eventsForDate.size(); ++eventIndex) {
+			auto &currentEvent = eventsForDate.at(eventIndex);
+			auto slintTasks = std::make_shared<slint::VectorModel<ui::TaskData>>();
+			slintEvents->push_back(
+				ui::Event{
+					.sourceId = currentEvent.sourceId(),
+					.id = currentEvent.id(),
+					.title = slint::SharedString(currentEvent.title()),
+					.startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),
+					.endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),
+					.tasks = slintTasks,
+				}
+			);
+			auto eventTasks = currentEvent.queryTasks();
+			for (int taskIndex = 0; taskIndex < eventTasks.size(); ++taskIndex) {
+				auto &task = eventTasks.at(taskIndex);
+				slintTasks->push_back({
+					.sourceId = task.sourceId(),
+					.eventId = currentEvent.id(),
+					.id = task.id(),
+					.title = slint::SharedString(task.title()),
+					.checked = task.checked(),
+				});
+			}
+		}
+	}
+	days_ = slintDays;
+	models().set_days(days_);
+
+	auto unscheduledTasksView = view_.getUnscheduledTasks();
+	unscheduledTasks_->clear();
+	for (int taskIndex = 0; taskIndex < unscheduledTasksView.size(); ++taskIndex) {
+		auto &task = unscheduledTasksView.at(taskIndex);
+		const auto &source = miraiInstance_->getSourceById(task.sourceId());
+		std::println("request name for source id {} : {}", task.sourceId(), source->name());
+		unscheduledTasks_->push_back({
+			.sourceId = task.sourceId(),
+			.eventId = -1,
+			.id = task.id(),
+			.title = slint::SharedString(task.title()),
+			.checked = task.checked(),
+		});
+	}
+	models().set_unscheduled_tasks(unscheduledTasks_);
+
+	calendar_->clear();
+	for (int dayIndex = 0; dayIndex < 7; ++dayIndex) {
+		std::chrono::year_month_day nextDate =
+			std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now()) +
+			std::chrono::days{dayIndex};
+		auto currentDate = mirai::Date{nextDate};
+		auto events = view_.getEventsForDate(currentDate);
+		auto slintEvents = std::make_shared<slint::VectorModel<ui::CalendarDayEvent>>();
+		auto relativeDaysDiff = std::chrono::duration_cast<std::chrono::days>(
+									std::chrono::sys_days(currentDate.toStdChrono()) -
+									std::chrono::sys_days(todayDate.toStdChrono())
+		)
+									.count();
+		if (relativeDaysDiff < 0 || relativeDaysDiff >= 7) {
 			continue;
 		}
-		auto events_for_date = get_events_for_date(all_events, current_date);
-		for (int event_index = 0; event_index < events_for_date.size(); ++event_index) {
-			auto &current_event = events_for_date.at(event_index);
-			new_slint_events->push_back(
-				ui::CalendarViewEvent{
-					.source_id = current_event.source_id(),
-					.id = current_event.id(),
-					.title = slint::SharedString(current_event.title()),
-					.starts_at = MiraiTimeToSlintTime(current_event.starts_at()),
-					.ends_at = MiraiTimeToSlintTime(current_event.ends_at()),
+		const std::vector<mirai::Event> eventsForDate = view_.getEventsForDate(currentDate);
+		for (int eventIndex = 0; eventIndex < eventsForDate.size(); ++eventIndex) {
+			auto &currentEvent = eventsForDate.at(eventIndex);
+			slintEvents->push_back(
+				ui::CalendarDayEvent{
+					.sourceId = currentEvent.sourceId(),
+					.id = currentEvent.id(),
+					.title = slint::SharedString(currentEvent.title()),
+					.startsAt = MiraiTimeToSlintTime(currentEvent.startsAt()),
+					.endsAt = MiraiTimeToSlintTime(currentEvent.endsAt()),
 				}
 			);
 		}
 
-		auto new_slint_date = ui::CalendarViewDate{
-			.events = new_slint_events,
-			.date = MiraiDateToSlintDate(current_date),
+		auto calendarDay = ui::CalendarDay{
+			.events = slintEvents,
+			.date = MiraiDateToSlintDate(currentDate),
 			.header = slint::SharedString(
-				capitalize(formatDateRelative(MiraiDateToSlintDate(current_date)))
+				capitalize(formatDateRelative(MiraiDateToSlintDate(currentDate)))
 			)
 		};
-		new_slint_dates->push_back(new_slint_date);
-	}
-	_calendar_view.dates = new_slint_dates;
-	models().set_calendar_view(_calendar_view);
-}
-
-std::vector<mirai::Task>
-get_all_tasks_from_sources(std::vector<std::unique_ptr<mirai::source>> &sources)
-{
-	std::vector<mirai::Task> all_tasks;
-	for (auto &source : sources) {
-		const auto &tasks = source->get_tasks();
-		all_tasks.insert(all_tasks.end(), tasks.begin(), tasks.end());
-	}
-	std::sort(all_tasks.begin(), all_tasks.end(), [](const mirai::Task &t1, const mirai::Task &t2) {
-		if (!t1.has_due_date() && !t2.has_due_date()) {
-			return false;
-		}
-		if (t1.has_due_date() && !t2.has_due_date()) {
-			return true;
-		}
-		if (!t1.has_due_date() && t2.has_due_date()) {
-			return false;
-		}
-		return t1.due_date() < t2.due_date();
-	});
-	return all_tasks;
-}
-
-struct tasks_source_group {
-	int id;
-	std::vector<mirai::Task> tasks;
-};
-
-struct tasks_date_group {
-	std::optional<mirai::Date> date;
-	std::vector<tasks_source_group> sources;
-};
-
-std::vector<tasks_date_group> group_tasks_by_date(const std::vector<mirai::Task> &tasks)
-{
-	if (tasks.size() == 0) {
-		return {};
-	}
-
-	std::vector<tasks_date_group> dates_group;
-	int next_task_index = 0;
-
-	mirai::Task current_task = tasks.at(next_task_index);
-
-	while (next_task_index < tasks.size()) {
-		tasks_date_group date_group{.date = current_task.due_date()};
-
-		while (next_task_index < tasks.size() && current_task.due_date() == date_group.date) {
-			tasks_source_group source_group{.id = current_task.source_id()};
-
-			while (next_task_index < tasks.size() && current_task.due_date() == date_group.date
-				   && current_task.source_id() == source_group.id) {
-				source_group.tasks.push_back(current_task);
-				next_task_index++;
-				if (next_task_index >= tasks.size()) {
-					break;
-				}
-				current_task = tasks.at(next_task_index);
-			}
-			date_group.sources.push_back(source_group);
-		}
-		dates_group.push_back(date_group);
-	}
-
-	return dates_group;
-};
-
-void AppWindow::update_tasks_view()
-{
-	auto today = mirai::Date(std::chrono::system_clock::now());
-	auto new_slint_dates = std::make_shared<slint::VectorModel<ui::TasksViewDate>>();
-
-	auto &sources = miraiInstance_->getSources();
-	auto all_tasks_dates = group_tasks_by_date(get_all_tasks_from_sources(sources));
-
-	for (int date_index = 0; date_index < all_tasks_dates.size(); ++date_index) {
-		auto &current_date_group = all_tasks_dates.at(date_index);
-		auto &current_date = current_date_group.date;
-		std::optional<int> relative_days_diff = std::nullopt;
-		if (current_date.has_value()) {
-			relative_days_diff = std::chrono::duration_cast<std::chrono::days>(
-									 std::chrono::sys_days(current_date.value().toStdChrono())
-									 - std::chrono::sys_days(today.toStdChrono())
-			)
-									 .count();
-		}
-
-		auto new_slint_sources = std::make_shared<slint::VectorModel<ui::TasksViewSource>>();
-		for (auto &source : current_date_group.sources) {
-			auto new_slint_source = ui::TasksViewSource();
-			auto new_slint_tasks = std::make_shared<slint::VectorModel<ui::TasksViewTask>>();
-			for (auto &task : source.tasks) {
-				if (task.has_due_date() && task.due_date() < today) {
-					continue;
-				}
-				new_slint_tasks->push_back(
-					{.id = task.id(),
-					 .source_id = source.id,
-					 .title = slint::SharedString(task.title()),
-					 .checked = task.checked()}
-				);
-			}
-			new_slint_source.tasks = new_slint_tasks;
-			new_slint_source.id = source.id;
-			new_slint_source.name =
-				slint::SharedString(miraiInstance_->getSourceById(source.id)->name());
-			const auto color =
-				selenite::hexStringToColor(miraiInstance_->getSourceById(source.id)->color());
-			new_slint_source.color = slint::Color::from_rgb_uint8(color.r, color.g, color.b);
-			if (new_slint_source.tasks->row_count() > 0) {
-				new_slint_sources->push_back(new_slint_source);
-			}
-		}
-		auto new_slint_date = ui::TasksViewDate{
-			.sources = new_slint_sources,
-		};
-
-		if (current_date.has_value()) {
-			new_slint_date.due_date = MiraiDateToSlintDate(current_date.value());
-			new_slint_date.is_late = current_date.value() < today;
-		} else {
-			new_slint_date.no_date = true;
-		}
-
-		if (new_slint_date.sources->row_count() > 0) {
-			new_slint_dates->push_back(new_slint_date);
-		}
-		_tasks_view.dates = new_slint_dates;
-		models().set_tasks_view(_tasks_view);
+		calendar_->push_back(calendarDay);
 	}
 }
 
-void AppWindow::show_source(const mirai::source &source)
+void AppWindow::reloadSources()
 {
+	sources_->clear();
+	bool noSourceSelected = miraiInstance_->getSources().size() == view_.activeSourceCount();
+	for (const auto &source : miraiInstance_->getSources()) {
+		bool isSourceSelected = view_.isSourceSelected(*source);
+		mirai::MarkdownDataProvider *sourceProvider =
+			dynamic_cast<mirai::MarkdownDataProvider *>(source->dataProvider());
+		sources_->push_back(
+			{.id = source->id,
+			 .name = slint::SharedString(source->name()),
+			 .selected = isSourceSelected && !noSourceSelected,
+			 .path = slint::SharedString(sourceProvider->path())}
+		);
+	}
+	models().set_no_source_selected(noSourceSelected);
 }
 
-void AppWindow::show_all_sources()
+void AppWindow::refreshModels()
 {
-}
-
-void AppWindow::hide_all_sources()
-{
-}
-
-void AppWindow::show_completed_tasks()
-{
-}
-
-void AppWindow::hide_completed_tasks()
-{
-}
-
-bool AppWindow::should_hide_completed_tasks() const
-{
-	return true;
+	view_.setAllSources();
+	view_.update();
+	reloadSources();
+	reloadTasks();
 }
 
 void AppWindow::run()
diff --git a/src/windows/AppWindow/AppWindow.h b/src/windows/AppWindow/AppWindow.h
index f02af42..0e40423 100644
--- a/src/windows/AppWindow/AppWindow.h
+++ b/src/windows/AppWindow/AppWindow.h
@@ -7,10 +7,9 @@
 #pragma once
 
 #include "mirai-core/Mirai.h"
-#include "mirai-core/Source.h"
+#include "mirai-core/View.h"
 #include "slint.h"
 #include "ui.h"
-#include <vector>
 
 class AppWindow
 {
@@ -24,32 +23,18 @@ class AppWindow
 	void reloadTasks();
 	void refreshModels();
 
-	void update_views();
-	void update_sidebar_view();
-	void update_calendar_view();
-	void update_tasks_view();
-
-	void show_all_sources();
-	void show_source(const mirai::source &source);
-	void hide_all_sources();
-
-	void show_completed_tasks();
-	void hide_completed_tasks();
-	bool should_hide_completed_tasks() const;
-
   private:
 	void setupCallbacks();
 	const ui::AppModels &models();
 	const ui::AppActions &actions();
 
-	ui::SidebarView _sidebar_view;
-	ui::TasksView _tasks_view;
-	ui::CalendarView _calendar_view;
+	std::shared_ptr<slint::VectorModel<ui::Source>> sources_;
+	std::shared_ptr<slint::VectorModel<ui::Day>> days_;
+	std::shared_ptr<slint::VectorModel<ui::CalendarDay>> calendar_;
+	std::shared_ptr<slint::VectorModel<ui::TaskData>> unscheduledTasks_;
 
 	slint::ComponentHandle<ui::AppWindow> mainWindow_ = ui::AppWindow::create();
 
 	mirai::Mirai *miraiInstance_;
-
-	std::vector<int> _source_filters;
-	bool _should_hide_completed_tasks;
+	mirai::View view_;
 };
diff --git a/src/windows/AppWindow/views/CalendarView.slint b/src/windows/AppWindow/views/CalendarView.slint
index 6c9bf79..422c2e6 100644
--- a/src/windows/AppWindow/views/CalendarView.slint
+++ b/src/windows/AppWindow/views/CalendarView.slint
@@ -1,7 +1,8 @@
-import { AppModels } from "../../../shared/Models.slint";
+import { AppModels, TaskData } from "../../../shared/Models.slint";
 import { AppActions, NewTaskData, SaveTaskData } from "../../../shared/Actions.slint";
 import { Button, VerticalBox, CheckBox, ScrollView, ComboBox } from "std-widgets.slint";
 import { TaskLine } from "../../../components/TaskLine.slint";
+import { EventGroup } from "../../../components/EventGroup.slint";
 import { Calendar } from "../../../components/Calendar.slint";
 import { VDatePicker, VTimePicker, VCheckBox, VButton, VTag, VText, VTextInput, Svg, Palette } from "@selenite";
 import { CreateTaskOrEvent } from "../../../components/CreateTaskOrEvent.slint";
@@ -40,7 +41,7 @@ export component CalendarView inherits Rectangle {
 			delete-event-request(source-id, event-id) => { 
 				AppActions.delete-event(source-id, event-id)
 			}
-			days: AppModels.calendar-view.dates;
+			days: AppModels.calendar;
 			current-date: Utils.current-date;
 			current-time: Utils.current-time;
 		}
diff --git a/src/windows/AppWindow/views/SideBar.slint b/src/windows/AppWindow/views/SideBar.slint
index ee6f4ba..d61fe3d 100644
--- a/src/windows/AppWindow/views/SideBar.slint
+++ b/src/windows/AppWindow/views/SideBar.slint
@@ -1,4 +1,4 @@
-import { AppModels } from "../../../shared/Models.slint";
+import { AppModels, TaskData } from "../../../shared/Models.slint";
 import { AppActions } from "../../../shared/Actions.slint";
 import { VButton, ToggleButton, VActionButton, VText, Svg, Palette } from "@selenite";
 import { EditSourceModal } from "../../../modals/EditSourceModal.slint";
@@ -10,7 +10,7 @@ export component SideBar inherits Rectangle {
 		editSourcePopup.edit(source-id)
 	}
 
-	addSourcePopup := AddSourceModal{}
+	addSourcePopup :=  AddSourceModal{}
 	editSourcePopup := EditSourceModal {}
 
 	VerticalLayout {
@@ -46,17 +46,17 @@ export component SideBar inherits Rectangle {
 				ToggleButton {
 					text: "All";
 					text-alignment: left;
-					active: AppModels.sidebar-view.all-active;
+					active: AppModels.no-source-selected;
 					clicked => { AppActions.source-clicked(-1) }
 
 					
 				}
-				for source[index] in AppModels.sidebar-view.sources: ToggleButton {
-					text: source.name;
+				for item[index] in AppModels.sources-selected: ToggleButton {
+					text: item.name;
 					text-alignment: left;
-					active: source.active;
-					clicked => { AppActions.source-clicked(source.id) }
-					right-clicked => { editSourcePopup.edit(source.id) }
+					active: item.selected;
+					clicked => { AppActions.source-clicked(item.id) }
+					right-clicked => { editSourcePopup.edit(item.id) }
 				}
 			}
 			VerticalLayout {
diff --git a/src/windows/AppWindow/views/TasksView.slint b/src/windows/AppWindow/views/TasksView.slint
index b1aa0dd..0879f2e 100644
--- a/src/windows/AppWindow/views/TasksView.slint
+++ b/src/windows/AppWindow/views/TasksView.slint
@@ -1,7 +1,8 @@
-import { AppModels } from "../../../shared/Models.slint";
+import { AppModels, TaskData } from "../../../shared/Models.slint";
 import { AppActions, NewTaskData, SaveTaskData } from "../../../shared/Actions.slint";
 import { Button, VerticalBox, CheckBox, ScrollView, ComboBox } from "std-widgets.slint";
 import { TaskLine } from "../../../components/TaskLine.slint";
+import { EventGroup } from "../../../components/EventGroup.slint";
 import { Calendar } from "../../../components/Calendar.slint";
 import { VPopupIconMenu, VDatePicker, VTimePicker, VCheckBox, VButton, VTag, VText, VTextInput, Svg, Palette } from "@selenite";
 import { CreateTaskOrEvent } from "../../../components/CreateTaskOrEvent.slint";
@@ -36,7 +37,7 @@ export component MainView inherits Rectangle {
 		}
 
 		CreateTaskOrEvent {
-			sources: AppModels.tasks-view.sources;
+			sources: AppModels.sources;
 			create-task(data) => {
 				AppActions.create-task({
 					sourceId: data.sourceId,
@@ -53,66 +54,106 @@ export component MainView inherits Rectangle {
 			horizontal-stretch: 1;
 			VerticalLayout {
 				alignment: start;
-				if AppModels.tasks-view.dates.length == 0 : VText {
+				if AppModels.days.length == 0 && AppModels.unscheduled-tasks.length == 0 : VText {
 					text: "There is no task to show";
 					horizontal-alignment: center;
 					vertical-alignment: center;
 				}
-				for day[dayIndex] in AppModels.tasks-view.dates: VerticalLayout {
-					spacing: day.sources.length > 0 ? 16px : 0px;
+				for day[dayIndex] in AppModels.days: VerticalLayout {
+					spacing: day.tasks.length > 0 ? 16px : 0px;
 					padding-bottom: 32px;
-
-					HorizontalLayout {
-						alignment: start;
-						VText {
-							text: day.no-date ? "Unscheduled" : Utils.format-date(day.due-date);
-							color: day.is-late ? Palette.orange : Palette.foreground;
-							font-size: 1.2rem;
+					
+					if day.tasks.length > 0 : Rectangle {
+						border-radius: 8px;
+						VerticalLayout {
+							HorizontalLayout {
+								alignment: start;
+								VText {
+									text: Utils.format-date(day.date);
+									color: day.isLate ? Palette.orange : Palette.foreground;
+									font-size: 1.2rem;
+								}
+								VerticalLayout {
+									alignment: center;
+									VText {
+										text: day.relativeDaysDiff == 0 ? "  -  today" :
+											day.relativeDaysDiff == 1 ? "  -  tomorrow" :
+											day.relativeDaysDiff == -1 ? "  -  yesterday" :
+											day.relativeDaysDiff > 0 ? "  -  in \{day.relativeDaysDiff} days" :
+											"  -  \{-day.relativeDaysDiff} days ago";
+										color: Palette.foreground-hint;
+										font-size: 1rem;
+									}
+								}
+							}
+							
+							for task[taskIndex] in day.tasks: VerticalLayout {
+								padding-top: taskIndex == 0 ? 16px : 0px;
+								padding-bottom: 8px;
+								TaskLine {
+									title: task.title;
+									source-name: AppModels.get-source-name-from-id(task.sourceId);
+									source-color: AppModels.get-source-color-from-id-as-color(task.sourceId);
+									scheduled: task.date.year != 0;
+									date: day.date;
+									checked: task.checked;
+									allow-edit-date: true;
+									delete => { 
+										AppActions.delete-task-clicked(task.sourceId, task.id)
+									}
+									toggle-check => {
+										AppActions.task-clicked(task.sourceId, task.id);
+									}
+									edited(data) => {
+										AppActions.save-task({
+											id: task.id,
+											sourceId: task.sourceId,
+											title: data.title,
+											scheduled: data.scheduled,
+											date: data.date
+										})
+									}
+								}
+							}
 						}
-						//VerticalLayout {
-							//alignment: center;
-							//VText {
-								//text: day.relativeDaysDiff == 0 ? "  -  today" :
-									//day.relativeDaysDiff == 1 ? "  -  tomorrow" :
-									//day.relativeDaysDiff == -1 ? "  -  yesterday" :
-									//day.relativeDaysDiff > 0 ? "  -  in \{day.relativeDaysDiff} days" :
-									//"  -  \{-day.relativeDaysDiff} days ago";
-								//color: Palette.foreground-hint;
-								//font-size: 1rem;
-							//}
-						//}
 					}
-
-					for source[source-index] in day.sources: VerticalLayout {
-						VText {
-							text: source.name;
-						}
-						if source.tasks.length > 0 : Rectangle {
-							VerticalLayout {
-								for task[taskIndex] in source.tasks: VerticalLayout {
-									padding-top: taskIndex == 0 ? 16px : 0px;
-									padding-bottom: 8px;
-									TaskLine {
-										title: task.title;
-										source-name: AppModels.get-source-name-from-id(task.source-id);
-										source-color: AppModels.get-source-color-from-id-as-color(task.source-id);
-										checked: task.checked;
-										allow-edit-date: true;
-										delete => { 
-											AppActions.delete-task-clicked(task.source-id, task.id)
-										}
-										toggle-check => {
-											AppActions.task-clicked(task.source-id, task.id);
-										}
-										edited(data) => {
-											AppActions.save-task({
-												id: task.id,
-												sourceId: task.source-id,
-												title: data.title,
-												scheduled: data.scheduled,
-												date: data.date
-											})
-										}
+				}
+				if AppModels.unscheduled-tasks.length > 0 : VerticalLayout {
+					Rectangle {
+						//background: Palette.card-background;
+						border-radius: 8px;
+						VerticalLayout {
+							HorizontalLayout {
+								alignment: start;
+								VText {
+									text: "Unscheduled";
+									color: Palette.foreground;
+									font-size: 1.2rem;
+								}
+							}
+							for task[taskIndex] in AppModels.unscheduled-tasks: VerticalLayout {
+								padding-top: taskIndex == 0 ? 16px : 0px;
+								padding-bottom: 8px;
+								TaskLine {
+									title: task.title;
+									source-name: AppModels.get-source-name-from-id(task.sourceId);
+									source-color: AppModels.get-source-color-from-id-as-color(task.sourceId);
+									checked: task.checked;
+									allow-edit-date: true;
+									delete => { 
+										AppActions.delete-task-clicked(task.sourceId, task.id)
+									}
+									toggle-check => {
+										AppActions.task-clicked(task.sourceId, task.id);
+									}
+									edited(data) => {
+										AppActions.save-task({
+											id: task.id,
+											sourceId: task.sourceId,
+											title: data.title,
+											scheduled: data.scheduled,
+											date: data.date
+										})
 									}
 								}
 							}