diff --git a/external/mirai-core/include/mirai-core/DataProvider.h b/external/mirai-core/include/mirai-core/DataProvider.h
index a2798db..fca7327 100644
--- a/external/mirai-core/include/mirai-core/DataProvider.h
+++ b/external/mirai-core/include/mirai-core/DataProvider.h
@@ -14,33 +14,33 @@
 namespace mirai
 {
 
-struct DayData {
+struct day_data {
 	int id;
 	Date date;
 };
 
-struct UpdatableDayData {
+struct updatable_day_data {
 	std::optional<Date> date;
 };
 
-enum TaskState { TODO, DONE };
+enum task_state { TODO, DONE };
 
-struct TaskData {
+struct task_data {
 	int id;
 	std::string title;
-	TaskState state;
+	task_state state;
 	std::optional<int> dayId;
 	std::optional<int> eventId;
 };
 
-struct UpdatableTaskData {
+struct updatable_task_data {
 	std::optional<std::string> title = std::nullopt;
-	std::optional<TaskState> state = std::nullopt;
+	std::optional<task_state> state = std::nullopt;
 	std::optional<std::optional<int>> dayId = std::nullopt;
 	std::optional<std::optional<int>> eventId = std::nullopt;
 };
 
-struct EventData {
+struct event_data {
 	int id;
 	int dayId;
 	std::string title;
@@ -48,69 +48,69 @@ struct EventData {
 	Time endsAt;
 };
 
-struct UpdatableEventData {
+struct updatable_event_data {
 	std::optional<int> dayId;
 	std::optional<std::string> title;
 	std::optional<Time> startsAt;
 	std::optional<Time> endsAt;
 };
 
-class DataProvider
+class data_provider
 {
 
   public:
-	DataProvider() {};
-	DataProvider(DataProvider &) = delete;
-	DataProvider(DataProvider &&) = delete;
+	data_provider() {};
+	data_provider(data_provider &) = delete;
+	data_provider(data_provider &&) = delete;
 
-	virtual ~DataProvider() = default;
+	virtual ~data_provider() = default;
 	virtual void save() = 0;
 	virtual void load() = 0;
 
 	virtual std::string name() const = 0;
 
 	// Tasks
-	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;
+	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_event_id(int eventId) = 0;
+	virtual std::vector<task_data> get_tasks_by_day_id(int dayId) = 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;
 
 	// Events
-	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;
+	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;
 
 	// 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;
+	virtual day_data insert_day(const day_data &day) = 0;
+	virtual void remove_day_by_id(int dayId) = 0;
+	virtual std::vector<day_data> get_days() = 0;
+	virtual std::optional<day_data> get_day_by_date(const Date &date) = 0;
+	virtual void update_day(int dayId, updatable_day_data updateData) = 0;
 
-	const int id = DataProvider::generateNextId();
+	const int id = data_provider::generate_next_id();
 
-	void setDirty(bool dirty)
+	void set_dirty(bool dirty)
 	{
-		isDirty_ = dirty;
+		_is_dirty = dirty;
 	};
 
-	bool isDirty() const
+	bool is_dirty() const
 	{
-		return isDirty_;
+		return _is_dirty;
 	};
 
   private:
-	bool isDirty_ = false;
+	bool _is_dirty = false;
 
-	static int generateNextId()
+	static int generate_next_id()
 	{
 		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
index a95f64f..6e2078d 100644
--- a/external/mirai-core/include/mirai-core/Day.h
+++ b/external/mirai-core/include/mirai-core/Day.h
@@ -19,7 +19,7 @@ class Day
 {
 
   public:
-	Day(DataProvider *data, DayData day) : data_(data), dayData_(day) {};
+	Day(data_provider *data, day_data day) : data_(data), dayData_(day) {};
 
 	Date date() const;
 	std::vector<Task> tasks();
@@ -31,8 +31,8 @@ class Day
 	int sourceId() const;
 
   private:
-	DayData dayData_;
-	DataProvider *data_;
+	day_data dayData_;
+	data_provider *data_;
 };
 
 } // namespace mirai
diff --git a/external/mirai-core/include/mirai-core/Event.h b/external/mirai-core/include/mirai-core/Event.h
index a2023cd..0ea8d56 100644
--- a/external/mirai-core/include/mirai-core/Event.h
+++ b/external/mirai-core/include/mirai-core/Event.h
@@ -20,7 +20,7 @@ class Event
 {
 
   public:
-	Event(DataProvider *data, EventData eventData) : data_(data), eventData_(eventData) {};
+	Event(data_provider *data, event_data eventData) : data_(data), eventData_(eventData) {};
 
 	std::string title() const;
 	Time startsAt() const;
@@ -37,8 +37,8 @@ class Event
 	int sourceId() const;
 
   private:
-	EventData eventData_;
-	DataProvider *data_;
+	event_data eventData_;
+	data_provider *data_;
 };
 
 } // namespace mirai
diff --git a/external/mirai-core/include/mirai-core/MarkdownDataProvider.h b/external/mirai-core/include/mirai-core/MarkdownDataProvider.h
index a88da83..f9dc0d8 100644
--- a/external/mirai-core/include/mirai-core/MarkdownDataProvider.h
+++ b/external/mirai-core/include/mirai-core/MarkdownDataProvider.h
@@ -19,22 +19,22 @@
 namespace mirai
 {
 
-struct MarkdownData {
+struct markdown_data {
 	std::string name;
-	std::vector<TaskData> tasks;
-	std::vector<DayData> days;
-	std::vector<EventData> events;
+	std::vector<task_data> tasks;
+	std::vector<day_data> days;
+	std::vector<event_data> events;
 };
 
-class MarkdownDataProvider : public DataProvider
+class markdown_data_provider : public data_provider
 {
   public:
-	MarkdownDataProvider(const std::string &filePath) : filePath_(filePath), DataProvider()
+	markdown_data_provider(const std::string &file_path) : _file_path(file_path), data_provider()
 	{
 	}
 
-	std::string toMarkdown();
-	MarkdownData parseMarkdown(const std::string &content);
+	std::string to_markdown();
+	markdown_data parse_markdown(const std::string &content);
 
 	std::string path() const;
 
@@ -44,35 +44,35 @@ class MarkdownDataProvider : public DataProvider
 	std::string name() const override;
 
 	// Tasks
-	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;
+	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_event_id(int eventId) override;
+	std::vector<task_data> get_tasks_by_day_id(int dayId) 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;
 
 	// Events
-	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;
+	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;
 
 	// 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;
+	day_data insert_day(const day_data &day) override;
+	void remove_day_by_id(int dayId) override;
+	std::vector<day_data> get_days() override;
+	std::optional<day_data> get_day_by_date(const Date &date) override;
+	void update_day(int dayId, updatable_day_data updateData) override;
 
   private:
-	std::string name_;
-	std::string filePath_;
-	MarkdownData data;
+	std::string _name;
+	std::string _file_path;
+	markdown_data _data;
 };
 
 } // namespace mirai
diff --git a/external/mirai-core/include/mirai-core/Mirai.h b/external/mirai-core/include/mirai-core/Mirai.h
index b0a39e7..83d3551 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<DataProvider> &&source
+		const std::string &name, const std::string &type, std::unique_ptr<data_provider> &&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 3a32b4c..b3143e9 100644
--- a/external/mirai-core/include/mirai-core/Source.h
+++ b/external/mirai-core/include/mirai-core/Source.h
@@ -33,24 +33,24 @@ struct createEventParams {
 struct SourceConstructor {
 	std::string name;
 	std::string color;
-	DataProvider *sourceDataProvider;
+	data_provider *sourceDataProvider;
 };
 
-class Source
+class source
 {
   public:
-	Source(SourceConstructor params)
-		: data(params.sourceDataProvider), 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();
@@ -59,44 +59,44 @@ class Source
 	std::string name() const;
 	std::string type() const;
 	std::string color() const;
-	DataProvider *dataProvider();
+	class data_provider *data_provider();
 
-	void setName(const std::string &name);
-	void setColor(const std::string &color);
+	void set_name(const std::string &name);
+	void set_color(const std::string &color);
 
-	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_task(const createTaskParams &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 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);
+	void create_event(const createEventParams &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);
 
-	std::vector<Day> getDays();
-	std::optional<Day> getDayByDate(Date date);
+	std::vector<Day> get_days();
+	std::optional<Day> get_day_by_date(Date date);
 
-	const int id = Source::generateNextId();
+	const int id = source::generate_next_id();
 
-	bool isDirty() const
+	bool is_dirty() const
 	{
-		return data->isDirty();
+		return data->is_dirty();
 	};
 
   private:
-	static int generateNextId()
+	static int generate_next_id()
 	{
 		static int nextId = 0;
 		return nextId++;
 	}
 
-	std::string name_;
-	std::string type_;
-	std::string color_;
-	DataProvider *data;
+	std::string _name;
+	std::string _type;
+	std::string _color;
+	class data_provider *data;
 };
 } // namespace mirai
diff --git a/external/mirai-core/include/mirai-core/Task.h b/external/mirai-core/include/mirai-core/Task.h
index cd9588f..7ae3cf2 100644
--- a/external/mirai-core/include/mirai-core/Task.h
+++ b/external/mirai-core/include/mirai-core/Task.h
@@ -19,10 +19,10 @@ class Task
 {
 
   public:
-	Task(DataProvider *data, TaskData task) : data_(data), task_(task) {};
+	Task(data_provider *data, task_data task) : data_(data), task_(task) {};
 
 	std::string title() const;
-	mirai::TaskState state() const;
+	mirai::task_state state() const;
 	bool checked() const;
 	bool hasEvent() const;
 	bool hasDate() const;
@@ -38,8 +38,8 @@ class Task
 	int sourceId() const;
 
   private:
-	TaskData task_;
-	DataProvider *data_;
+	task_data task_;
+	data_provider *data_;
 };
 
 } // namespace mirai
diff --git a/external/mirai-core/include/mirai-core/View.h b/external/mirai-core/include/mirai-core/View.h
index cd1295d..2bbb01d 100644
--- a/external/mirai-core/include/mirai-core/View.h
+++ b/external/mirai-core/include/mirai-core/View.h
@@ -40,10 +40,10 @@ class View
 	void update();
 
 	void removeSources();
-	void addSource(const Source &source);
-	void setSources(const std::vector<Source> &sources);
+	void addSource(const source &source);
+	void setSources(const std::vector<source> &sources);
 	void setAllSources();
-	bool isSourceSelected(const Source &source) const;
+	bool isSourceSelected(const source &source) const;
 
 	size_t activeSourceCount() const;
 
diff --git a/external/mirai-core/src/Day.cpp b/external/mirai-core/src/Day.cpp
index 1086cb4..e58f985 100644
--- a/external/mirai-core/src/Day.cpp
+++ b/external/mirai-core/src/Day.cpp
@@ -29,11 +29,11 @@ Date Day::date() const
 
 std::vector<Task> Day::tasks()
 {
-	auto tasksData = data_->getTasksByDayId(id());
+	auto tasksData = data_->get_tasks_by_day_id(id());
 	std::vector<Task> tasks;
 	std::transform(
 		tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
-		[&](const TaskData &taskData) {
+		[&](const task_data &taskData) {
 			return Task{data_, taskData};
 		}
 	);
@@ -42,11 +42,11 @@ std::vector<Task> Day::tasks()
 
 std::vector<Event> Day::events()
 {
-	auto eventsData = data_->getEventsByDate(dayData_.date);
+	auto eventsData = data_->get_events_by_date(dayData_.date);
 	std::vector<Event> events;
 	std::transform(
 		eventsData.begin(), eventsData.end(), std::back_inserter(events),
-		[&](const EventData &eventData) {
+		[&](const event_data &eventData) {
 			return Event{data_, eventData};
 		}
 	);
diff --git a/external/mirai-core/src/Event.cpp b/external/mirai-core/src/Event.cpp
index f5b0021..dd05384 100644
--- a/external/mirai-core/src/Event.cpp
+++ b/external/mirai-core/src/Event.cpp
@@ -38,11 +38,11 @@ Time Event::endsAt() const
 
 std::vector<Task> Event::queryTasks() const
 {
-	auto tasksData = data_->getTasksByEventId(eventData_.id);
+	auto tasksData = data_->get_tasks_by_event_id(eventData_.id);
 	std::vector<Task> tasks;
 	std::transform(
 		tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
-		[&](const TaskData &taskData) {
+		[&](const task_data &taskData) {
 			return Task{data_, taskData};
 		}
 	);
@@ -51,21 +51,21 @@ std::vector<Task> Event::queryTasks() const
 
 void Event::setTitle(const std::string &newTitle)
 {
-	data_->updateEvent(id(), {.title = newTitle});
+	data_->update_event(id(), {.title = newTitle});
 }
 
 void Event::setDay(const Day &day)
 {
-	data_->updateEvent(id(), {.dayId = day.id()});
+	data_->update_event(id(), {.dayId = day.id()});
 }
 
 void Event::setStartTime(const Time &time)
 {
-	data_->updateEvent(id(), {.startsAt = time});
+	data_->update_event(id(), {.startsAt = time});
 }
 
 void Event::setEndTime(const Time &time)
 {
-	data_->updateEvent(id(), {.endsAt = time});
+	data_->update_event(id(), {.endsAt = time});
 }
 } // namespace mirai
diff --git a/external/mirai-core/src/MarkdownDataProvider.Parser.cpp b/external/mirai-core/src/MarkdownDataProvider.Parser.cpp
index e1bd7d4..7f7d644 100644
--- a/external/mirai-core/src/MarkdownDataProvider.Parser.cpp
+++ b/external/mirai-core/src/MarkdownDataProvider.Parser.cpp
@@ -37,16 +37,17 @@ std::string fieldWithSpace(const std::string &field)
 	return (field + " ");
 }
 
-TaskData stringToTask(const std::string &str, const std::string &date)
+task_data 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]);
 
-	TaskData taskItem{
+	task_data taskItem{
 		.title = text,
 		.state = str.substr(0, 5) == "- [X]" ? DONE : TODO,
 	};
@@ -69,7 +70,7 @@ Time stringToTime(const std::string &str)
 	return time;
 }
 
-EventData stringToEvent(const std::string &str, const std::string &dateString)
+event_data 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}) )(.*?)( -- (.*))?");
@@ -83,7 +84,7 @@ EventData stringToEvent(const std::string &str, const std::string &dateString)
 		throw std::runtime_error("Malformated date");
 	}
 
-	EventData eventData{
+	event_data eventData{
 		.title = text,
 		.startsAt = stringToTime(matches[2]),
 		.endsAt = stringToTime(matches[3]),
@@ -91,23 +92,23 @@ EventData stringToEvent(const std::string &str, const std::string &dateString)
 	return eventData;
 }
 
-std::string taskToString(const TaskData &task)
+std::string taskToString(const task_data &task)
 {
 	std::string str = task.title;
 	str = (task.state == DONE ? "- [X] " : "- [ ] ") + str;
 	return str;
 }
 
-std::string MarkdownDataProvider::toMarkdown()
+std::string markdown_data_provider::to_markdown()
 {
-	const std::vector<DayData> days = getDays();
+	const std::vector<day_data> days = get_days();
 	std::string result = "# " + name() + "\n\n";
 	std::string currentDate = "";
 
 	for (const auto &day : days) {
 		auto &date = day.date;
-		auto tasks = getTasksByDayId(day.id);
-		auto events = getEventsByDate(date);
+		auto tasks = get_tasks_by_day_id(day.id);
+		auto events = get_events_by_date(date);
 		if (tasks.size() == 0 && events.size() == 0) {
 			continue;
 		}
@@ -122,7 +123,7 @@ std::string MarkdownDataProvider::toMarkdown()
 						  end.minute, event.title
 					  ) +
 					  "\n";
-			for (const auto &task : getTasksByEventId(event.id)) {
+			for (const auto &task : get_tasks_by_event_id(event.id)) {
 				result += taskToString(task) + '\n';
 			}
 			result += '\n';
@@ -133,7 +134,7 @@ std::string MarkdownDataProvider::toMarkdown()
 		result += '\n';
 	}
 
-	auto unscheduledTasks = getTasksWithoutDate();
+	auto unscheduledTasks = get_tasks_without_date();
 	if (unscheduledTasks.size() > 0) {
 		result += "## Unscheduled\n\n";
 		for (const auto &task : unscheduledTasks) {
@@ -144,7 +145,7 @@ std::string MarkdownDataProvider::toMarkdown()
 	return result;
 };
 
-MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
+markdown_data markdown_data_provider::parse_markdown(const std::string &content)
 {
 	cpputils::debug::Timer readMdFormatDuration;
 
@@ -156,13 +157,13 @@ MarkdownData MarkdownDataProvider::parseMarkdown(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::vector<mirai::DayData> daysData;
-	std::vector<mirai::TaskData> unscheduledTasks;
+	std::vector<mirai::day_data> daysData;
+	std::vector<mirai::task_data> unscheduledTasks;
 	std::optional<Date> currentDate = std::nullopt;
-	std::optional<EventData> currentEvent = std::nullopt;
+	std::optional<event_data> currentEvent = std::nullopt;
 
 	cpputils::debug::Timer stringToTaskDuration;
 	stringToTaskDuration.reset();
@@ -178,11 +179,11 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
 			if (!currentDate.has_value()) {
 				throw std::runtime_error("Malformated date (1)");
 			}
-			insertDay({.id = generateUniqueId(), .date = currentDate.value()});
+			insert_day({.id = generateUniqueId(), .date = currentDate.value()});
 		} else if (line.starts_with("> ")) {
 			auto event = stringToEvent(line, currentDateString);
 			if (currentDate.has_value()) {
-				auto day = getDayByDate(currentDate.value());
+				auto day = get_day_by_date(currentDate.value());
 				currentEvent = insertEvent(
 					{.id = generateUniqueId(),
 					 .dayId = day->id,
@@ -193,10 +194,10 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
 			}
 		} else if (line.starts_with("- [ ]") || line.starts_with("- [X]")) {
 			stringToTaskDuration.start();
-			TaskData taskItemData = stringToTask(line, currentDateString);
+			task_data taskItemData = stringToTask(line, currentDateString);
 			stringToTaskDuration.stop();
 			if (currentEvent.has_value()) {
-				insertTask({
+				insert_task({
 					.id = generateUniqueId(),
 					.title = taskItemData.title,
 					.state = taskItemData.state,
@@ -204,8 +205,8 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
 					.eventId = currentEvent.value().id,
 				});
 			} else if (currentDate.has_value()) {
-				auto day = getDayByDate(currentDate.value());
-				insertTask({
+				auto day = get_day_by_date(currentDate.value());
+				insert_task({
 					.id = generateUniqueId(),
 					.title = taskItemData.title,
 					.state = taskItemData.state,
@@ -213,7 +214,7 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
 					.eventId = std::nullopt,
 				});
 			} else {
-				insertTask({
+				insert_task({
 					.id = generateUniqueId(),
 					.title = taskItemData.title,
 					.state = taskItemData.state,
@@ -229,6 +230,6 @@ MarkdownData MarkdownDataProvider::parseMarkdown(const std::string &content)
 	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 d72c3cf..1b0958a 100644
--- a/external/mirai-core/src/MarkdownDataProvider.cpp
+++ b/external/mirai-core/src/MarkdownDataProvider.cpp
@@ -18,33 +18,33 @@
 namespace mirai
 {
 
-std::string MarkdownDataProvider::path() const
+std::string markdown_data_provider::path() const
 {
-	return filePath_;
+	return _file_path;
 }
 
-std::string MarkdownDataProvider::name() const
+std::string markdown_data_provider::name() const
 {
-	return data.name;
+	return _data.name;
 }
 
-void MarkdownDataProvider::save()
+void markdown_data_provider::save()
 {
-	std::ofstream file(filePath_);
+	std::ofstream file(_file_path);
 	if (!file.is_open()) {
-		throw std::runtime_error("can't create " + filePath_);
+		throw std::runtime_error("can't create " + _file_path);
 	}
 
-	const std::string content = toMarkdown();
+	const std::string content = to_markdown();
 
 	file << content;
 	file.close();
-	setDirty(false);
+	set_dirty(false);
 };
 
-void MarkdownDataProvider::load()
+void markdown_data_provider::load()
 {
-	std::ifstream file(filePath_);
+	std::ifstream file(_file_path);
 	if (!file.is_open()) {
 		return;
 	}
@@ -55,19 +55,19 @@ void MarkdownDataProvider::load()
 		content += line + "\n";
 	}
 	file.close();
-	data = parseMarkdown(content);
+	_data = parse_markdown(content);
 };
 
-TaskData MarkdownDataProvider::insertTask(const TaskData &taskData)
+task_data markdown_data_provider::insert_task(const task_data &taskData)
 {
-	data.tasks.push_back(taskData);
-	setDirty(true);
+	_data.tasks.push_back(taskData);
+	set_dirty(true);
 	return taskData;
 }
 
-void MarkdownDataProvider::updateTask(int taskId, UpdatableTaskData updateData)
+void markdown_data_provider::update_task(int taskId, updatable_task_data updateData)
 {
-	auto taskData = ptrFindFirst(data.tasks, [&](const TaskData &task) {
+	auto taskData = ptrFindFirst(_data.tasks, [&](const task_data &task) {
 		return task.id == taskId;
 	});
 	assert(taskData != nullptr); // Shouldn't be possible
@@ -83,122 +83,122 @@ void MarkdownDataProvider::updateTask(int taskId, UpdatableTaskData updateData)
 	if (updateData.eventId.has_value()) {
 		taskData->eventId = updateData.eventId.value();
 	}
-	setDirty(true);
+	set_dirty(true);
 }
 
-std::optional<TaskData> MarkdownDataProvider::getTaskById(int taskId)
+std::optional<task_data> markdown_data_provider::get_task_by_id(int taskId)
 {
-	return findFirst(data.tasks, [&](const TaskData &task) {
+	return findFirst(_data.tasks, [&](const task_data &task) {
 		return task.id == taskId;
 	});
 }
 
-std::vector<TaskData> MarkdownDataProvider::getTasksByEventId(int eventId)
+std::vector<task_data> markdown_data_provider::get_tasks_by_event_id(int eventId)
 {
-	return findAll(data.tasks, [&](const TaskData &task) {
+	return findAll(_data.tasks, [&](const task_data &task) {
 		return task.eventId == eventId;
 	});
 }
 
-std::vector<TaskData> MarkdownDataProvider::getTasksByDayId(int dayId)
+std::vector<task_data> markdown_data_provider::get_tasks_by_day_id(int dayId)
 {
-	return findAll(data.tasks, [&](const TaskData &task) {
+	return findAll(_data.tasks, [&](const task_data &task) {
 		return task.dayId == dayId;
 	});
 }
 
-std::vector<TaskData> MarkdownDataProvider::getTasksWithoutDate()
+std::vector<task_data> markdown_data_provider::get_tasks_without_date()
 {
-	return findAll(data.tasks, [](const TaskData &t) {
+	return findAll(_data.tasks, [](const task_data &t) {
 		return t.dayId == std::nullopt && t.eventId == std::nullopt;
 	});
 }
 
-std::vector<TaskData> MarkdownDataProvider::getTasksByDate(Date date)
+std::vector<task_data> markdown_data_provider::get_tasks_by_date(Date date)
 {
-	auto day = getDayByDate(date);
+	auto day = get_day_by_date(date);
 	if (!day.has_value()) {
 		return {};
 	}
-	return findAll(data.tasks, [&](const TaskData &t) {
+	return findAll(_data.tasks, [&](const task_data &t) {
 		return t.dayId == day.value().id;
 	});
 }
 
-std::vector<TaskData> MarkdownDataProvider::getTasks()
+std::vector<task_data> markdown_data_provider::get_tasks()
 {
-	return data.tasks;
+	return _data.tasks;
 }
 
-void MarkdownDataProvider::removeTaskById(int taskId)
+void markdown_data_provider::remove_task_by_id(int taskId)
 {
-	data.tasks.erase(
+	_data.tasks.erase(
 		std::remove_if(
-			data.tasks.begin(), data.tasks.end(),
-			[&](const TaskData &task) {
+			_data.tasks.begin(), _data.tasks.end(),
+			[&](const task_data &task) {
 				return task.id == taskId;
 			}
 		),
-		data.tasks.end()
+		_data.tasks.end()
 	);
-	setDirty(true);
+	set_dirty(true);
 }
 
-DayData MarkdownDataProvider::insertDay(const DayData &dayData)
+day_data markdown_data_provider::insert_day(const day_data &dayData)
 {
-	data.days.push_back(dayData);
-	setDirty(true);
+	_data.days.push_back(dayData);
+	set_dirty(true);
 	return dayData;
 }
 
-void MarkdownDataProvider::updateDay(int dayId, UpdatableDayData updateData)
+void markdown_data_provider::update_day(int dayId, updatable_day_data updateData)
 {
-	auto dayData = ptrFindFirst(data.days, [&](const DayData &day) {
+	auto dayData = ptrFindFirst(_data.days, [&](const day_data &day) {
 		return day.id == dayId;
 	});
 	assert(dayData != nullptr); // Shouldn't be possible
 	if (updateData.date.has_value()) {
 		dayData->date = updateData.date.value();
 	}
-	setDirty(true);
+	set_dirty(true);
 }
 
-void MarkdownDataProvider::removeDayById(int dayId)
+void markdown_data_provider::remove_day_by_id(int dayId)
 {
-	data.days.erase(
+	_data.days.erase(
 		std::remove_if(
-			data.days.begin(), data.days.end(),
-			[&](const DayData &day) {
+			_data.days.begin(), _data.days.end(),
+			[&](const day_data &day) {
 				return day.id == dayId;
 			}
 		),
-		data.days.end()
+		_data.days.end()
 	);
-	setDirty(true);
+	set_dirty(true);
 }
 
-std::vector<DayData> MarkdownDataProvider::getDays()
+std::vector<day_data> markdown_data_provider::get_days()
 {
-	return data.days;
+	return _data.days;
 }
 
-std::optional<DayData> MarkdownDataProvider::getDayByDate(const Date &date)
+std::optional<day_data> markdown_data_provider::get_day_by_date(const Date &date)
 {
-	return findFirst(data.days, [&](const DayData &day) {
+	return findFirst(_data.days, [&](const day_data &day) {
 		return day.date == date;
 	});
 }
 
-EventData MarkdownDataProvider::insertEvent(const EventData &eventData)
+event_data markdown_data_provider::insertEvent(const event_data &eventData)
 {
-	data.events.push_back(eventData);
-	setDirty(true);
+	_data.events.push_back(eventData);
+	set_dirty(true);
 	return eventData;
 }
 
-void MarkdownDataProvider::updateEvent(int eventId, UpdatableEventData updateData)
+void markdown_data_provider::update_event(int eventId, updatable_event_data updateData)
 {
-	auto eventData = ptrFindFirst(data.events, [&](const EventData &event) {
+	auto eventData = ptrFindFirst(_data.events, [&](const event_data &event) {
 		return event.id == eventId;
 	});
 	assert(eventData != nullptr); // Shouldn't be possible
@@ -214,43 +214,43 @@ void MarkdownDataProvider::updateEvent(int eventId, UpdatableEventData updateDat
 	if (updateData.endsAt.has_value()) {
 		eventData->endsAt = updateData.endsAt.value();
 	}
-	setDirty(true);
+	set_dirty(true);
 }
 
-void MarkdownDataProvider::removeEventById(int eventId)
+void markdown_data_provider::remove_event_by_id(int eventId)
 {
-	data.events.erase(
+	_data.events.erase(
 		std::remove_if(
-			data.events.begin(), data.events.end(),
-			[&](const EventData &event) {
+			_data.events.begin(), _data.events.end(),
+			[&](const event_data &event) {
 				return event.id == eventId;
 			}
 		),
-		data.events.end()
+		_data.events.end()
 	);
-	setDirty(true);
+	set_dirty(true);
 }
 
-std::optional<EventData> MarkdownDataProvider::getEventById(int eventId)
+std::optional<event_data> markdown_data_provider::get_event_by_id(int eventId)
 {
-	return findFirst(data.events, [&](const EventData &event) {
+	return findFirst(_data.events, [&](const event_data &event) {
 		return event.id == eventId;
 	});
 }
 
-std::vector<EventData> MarkdownDataProvider::getEventsByDate(Date date)
+std::vector<event_data> markdown_data_provider::get_events_by_date(Date date)
 {
-	auto day = getDayByDate(date);
+	auto day = get_day_by_date(date);
 	if (!day.has_value()) {
 		return {};
 	}
-	return findAll(data.events, [&](const EventData &event) {
+	return findAll(_data.events, [&](const event_data &event) {
 		return event.dayId == day.value().id;
 	});
 }
 
-std::vector<EventData> MarkdownDataProvider::getEvents()
+std::vector<event_data> markdown_data_provider::get_events()
 {
-	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 5f7683a..8f0f162 100644
--- a/external/mirai-core/src/Mirai.cpp
+++ b/external/mirai-core/src/Mirai.cpp
@@ -43,11 +43,11 @@ 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<DataProvider> file = std::make_unique<MarkdownDataProvider>(path);
-		DataProvider *sourceDataProvider = file.release();
+		std::unique_ptr<data_provider> file = std::make_unique<markdown_data_provider>(path);
+		data_provider *sourceDataProvider = file.release();
 		sourceDataProvider->load();
 		sources_.push_back(
-			std::make_unique<Source>(SourceConstructor{
+			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<MarkdownDataProvider *>(source->dataProvider());
+		auto dataProvider = dynamic_cast<markdown_data_provider *>(source->data_provider());
 		jsonSource.set("path", dataProvider->path());
 		jsonSource.set("type", "FileSystemMarkdown");
 		configJson.getArray("files").push(jsonSource);
@@ -84,13 +84,13 @@ Mirai::Mirai(const std::string &configFilePath) : configPath_(configFilePath)
 }
 
 void Mirai::addSource(
-	const std::string &name, const std::string &type, std::unique_ptr<DataProvider> &&source
+	const std::string &name, const std::string &type, std::unique_ptr<data_provider> &&new_source
 )
 {
-	DataProvider *sourceDataProvider = source.release();
+	data_provider *sourceDataProvider = new_source.release();
 	sourceDataProvider->load();
 	sources_.push_back(
-		std::make_unique<Source>(
+		std::make_unique<source>(
 			SourceConstructor{.name = name, .sourceDataProvider = sourceDataProvider}
 		)
 	);
@@ -103,21 +103,20 @@ void Mirai::editSource(
 )
 {
 	auto source = getSourceById(id);
-	source->setName(name);
-	source->setColor(color);
+	source->set_name(name);
+	source->set_color(color);
 
-	DataProvider *sourceDataProvider = source->dataProvider();
+	data_provider *sourceDataProvider = source->data_provider();
 	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) {
+			[&](const std::unique_ptr<source> &source) {
 				return source->id == id;
 			}
 		),
@@ -136,47 +135,47 @@ void Mirai::unloadAllSources()
 void Mirai::save()
 {
 	for (auto &source : sources_) {
-		if (source->isDirty()) {
+		if (source->is_dirty()) {
 			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 = std::ranges::find_if(sources_, [&](const std::unique_ptr<Source> &source) {
+	auto source_found = std::ranges::find_if(sources_, [&](const std::unique_ptr<source> &source) {
 		return source->id == id;
 	});
-	assert(source != sources_.end()); // This should not happen
-	if (source == sources_.end()) {
+	assert(source_found != sources_.end()); // This should not happen
+	if (source_found == sources_.end()) {
 		return nullptr;
 	}
-	return source->get();
+	return source_found->get();
 }
 
-Source *Mirai::getSourceByName(const std::string &name)
+source *Mirai::getSourceByName(const std::string &name)
 {
-	auto source = std::ranges::find_if(sources_, [&](const std::unique_ptr<Source> &source) {
+	auto source_found = std::ranges::find_if(sources_, [&](const std::unique_ptr<source> &source) {
 		return source->name() == name;
 	});
-	assert(source != sources_.end()); // This should not happen
-	if (source == sources_.end()) {
+	assert(source_found != sources_.end()); // This should not happen
+	if (source_found == sources_.end()) {
 		return nullptr;
 	}
-	return source->get();
+	return source_found->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 9ced168..6f0862c 100644
--- a/external/mirai-core/src/Source.cpp
+++ b/external/mirai-core/src/Source.cpp
@@ -16,20 +16,20 @@
 namespace mirai
 {
 
-void Source::save()
+void source::save()
 {
 	data->save();
 }
 
-void Source::createTask(const createTaskParams &task)
+void source::create_task(const createTaskParams &task)
 {
 	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());
+		auto day = data->get_day_by_date(task.date.value());
 		if (!day.has_value() && task.date.has_value()) {
-			day = data->insertDay({.id = generateUniqueId(), .date = task.date.value()});
+			day = data->insert_day({.id = generateUniqueId(), .date = task.date.value()});
 		}
 		dayId = day->id;
 	}
@@ -38,7 +38,7 @@ void Source::createTask(const createTaskParams &task)
 		eventId = task.event.value().id();
 	}
 
-	data->insertTask({
+	data->insert_task({
 		.id = generateUniqueId(),
 		.title = task.title,
 		.state = TODO,
@@ -47,34 +47,34 @@ void Source::createTask(const createTaskParams &task)
 	});
 };
 
-std::vector<Day> Source::getDays()
+std::vector<Day> source::get_days()
 {
-	auto daysData = data->getDays();
+	auto daysData = data->get_days();
 	std::vector<Day> days;
 	std::transform(
-		daysData.begin(), daysData.end(), std::back_inserter(days), [&](const DayData &dayData) {
+		daysData.begin(), daysData.end(), std::back_inserter(days), [&](const day_data &dayData) {
 			return Day{data, dayData};
 		}
 	);
 	return days;
 }
 
-std::optional<Day> Source::getDayByDate(Date date)
+std::optional<Day> source::get_day_by_date(Date date)
 {
-	auto day = data->getDayByDate(date);
+	auto day = data->get_day_by_date(date);
 	if (!day.has_value()) {
 		return std::nullopt;
 	}
 	return Day{data, day.value()};
 }
 
-void Source::createEvent(const createEventParams &eventToCreate)
+void source::create_event(const createEventParams &eventToCreate)
 {
 	std::optional<int> dayId = std::nullopt;
 
-	auto day = data->getDayByDate(eventToCreate.date);
+	auto day = data->get_day_by_date(eventToCreate.date);
 	if (!day.has_value()) {
-		day = data->insertDay({.id = generateUniqueId(), .date = eventToCreate.date});
+		day = data->insert_day({.id = generateUniqueId(), .date = eventToCreate.date});
 		dayId = day->id;
 	}
 
@@ -87,28 +87,28 @@ void Source::createEvent(const createEventParams &eventToCreate)
 	});
 };
 
-std::optional<Event> Source::getEventById(int evendId)
+std::optional<Event> source::get_event_by_id(int evendId)
 {
-	auto event = data->getEventById(evendId);
+	auto event = data->get_event_by_id(evendId);
 	if (!event.has_value()) {
 		return std::nullopt;
 	}
 	return Event{data, event.value()};
 }
 
-void Source::removeEvent(const Event &event)
+void source::remove_event(const Event &event)
 {
-	data->removeEventById(event.id());
+	data->remove_event_by_id(event.id());
 }
 
-void Source::removeTask(const Task &task)
+void source::remove_task(const Task &task)
 {
-	data->removeTaskById(task.id());
+	data->remove_task_by_id(task.id());
 }
 
-std::optional<Task> Source::getTaskById(int taskId)
+std::optional<Task> source::get_task_by_id(int taskId)
 {
-	auto taskData = data->getTaskById(taskId);
+	auto taskData = data->get_task_by_id(taskId);
 	if (!taskData.has_value()) {
 		return std::nullopt;
 	}
@@ -116,59 +116,59 @@ std::optional<Task> Source::getTaskById(int taskId)
 	return task;
 }
 
-std::vector<Task> Source::getTasks()
+std::vector<Task> source::get_tasks()
 {
-	auto tasksData = data->getTasks();
+	auto tasksData = data->get_tasks();
 	std::vector<Task> tasks;
 	std::transform(
 		tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
-		[&](const TaskData &taskData) {
+		[&](const task_data &taskData) {
 			return Task{data, taskData};
 		}
 	);
 	return tasks;
 }
 
-std::vector<Task> Source::getUnscheduledTasks()
+std::vector<Task> source::get_unscheduled_tasks()
 {
-	auto tasksData = data->getTasksWithoutDate();
+	auto tasksData = data->get_tasks_without_date();
 	std::vector<Task> tasks;
 	std::transform(
 		tasksData.begin(), tasksData.end(), std::back_inserter(tasks),
-		[&](const TaskData &taskData) {
+		[&](const task_data &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::setName(const std::string &name)
+void source::set_name(const std::string &name)
 {
-	name_ = name;
+	_name = name;
 }
 
-void Source::setColor(const std::string &color)
+void source::set_color(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;
 }
 
-DataProvider *Source::dataProvider()
+data_provider *source::data_provider()
 {
 	return data;
 }
diff --git a/external/mirai-core/src/Task.cpp b/external/mirai-core/src/Task.cpp
index 54c87ab..3b11c33 100644
--- a/external/mirai-core/src/Task.cpp
+++ b/external/mirai-core/src/Task.cpp
@@ -29,7 +29,7 @@ std::string Task::title() const
 	return task_.title;
 }
 
-mirai::TaskState Task::state() const
+mirai::task_state Task::state() const
 {
 	return task_.state;
 }
@@ -51,40 +51,40 @@ bool Task::hasDate() const
 
 void Task::setTitle(const std::string &newTitle)
 {
-	data_->updateTask(id(), {.title = newTitle});
+	data_->update_task(id(), {.title = newTitle});
 }
 
 void Task::setDay(const Day &day)
 {
 	auto emptyEventId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
-	data_->updateTask(id(), {.dayId = day.id(), .eventId = emptyEventId});
+	data_->update_task(id(), {.dayId = day.id(), .eventId = emptyEventId});
 }
 
 void Task::setDate(const Date &date)
 {
-	auto day = data_->getDayByDate(date);
+	auto day = data_->get_day_by_date(date);
 	if (!day.has_value()) {
-		day = data_->insertDay({.id = generateUniqueId(), .date = date});
+		day = data_->insert_day({.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});
+	data_->update_task(id(), {.dayId = day.value().id, .eventId = emptyEventId});
 }
 
 void Task::unschedule()
 {
 	auto emptyId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
-	data_->updateTask(id(), {.dayId = emptyId, .eventId = emptyId});
+	data_->update_task(id(), {.dayId = emptyId, .eventId = emptyId});
 }
 
 void Task::setEvent(const Event &event)
 {
 	auto emptyDayId = std::optional<std::optional<int>>(std::optional<int>(std::nullopt));
-	data_->updateTask(id(), {.dayId = emptyDayId, .eventId = event.id()});
+	data_->update_task(id(), {.dayId = emptyDayId, .eventId = event.id()});
 }
 
 void Task::setChecked(bool checked)
 {
-	data_->updateTask(id(), {.state = checked ? DONE : TODO});
+	data_->update_task(id(), {.state = checked ? DONE : TODO});
 }
 
 } // namespace mirai
diff --git a/external/mirai-core/src/View.cpp b/external/mirai-core/src/View.cpp
index 30471d3..6c2023c 100644
--- a/external/mirai-core/src/View.cpp
+++ b/external/mirai-core/src/View.cpp
@@ -63,8 +63,8 @@ void View::update()
 	auto todayDate = Date(std::chrono::system_clock::now());
 
 	for (int sourceId : sourcesIds_) {
-		Source *source = mirai_->getSourceById(sourceId);
-		for (auto day : source->getDays()) {
+		source *source = mirai_->getSourceById(sourceId);
+		for (auto day : source->get_days()) {
 			// day's tasks
 			auto sourceTasks = day.tasks() | std::ranges::views::filter([&](const Task &task) {
 								   if (day.date() >= todayDate) {
@@ -102,7 +102,7 @@ void View::update()
 			}
 		}
 		// unscheduled tasks
-		auto tasks = source->getUnscheduledTasks();
+		auto tasks = source->get_unscheduled_tasks();
 		unscheduledTasks_.insert(unscheduledTasks_.end(), tasks.begin(), tasks.end());
 	}
 
@@ -119,17 +119,16 @@ void View::removeSources()
 	sourcesIds_.clear();
 }
 
-void View::addSource(const Source &source)
+void View::addSource(const source &source)
 {
 	sourcesIds_.push_back(source.id);
 }
 
-void View::setSources(const std::vector<Source> &sources)
+void View::setSources(const std::vector<source> &sources)
 {
 	sourcesIds_.clear();
 	std::transform(
-		sources.begin(), sources.end(), std::back_inserter(sourcesIds_),
-		[](const Source &source) {
+		sources.begin(), sources.end(), std::back_inserter(sourcesIds_), [](const source &source) {
 			return source.id;
 		}
 	);
@@ -141,13 +140,13 @@ void View::setAllSources()
 	sourcesIds_.clear();
 	std::transform(
 		sources.begin(), sources.end(), std::back_inserter(sourcesIds_),
-		[](const std::unique_ptr<Source> &source) {
+		[](const std::unique_ptr<source> &source) {
 			return source->id;
 		}
 	);
 }
 
-bool View::isSourceSelected(const Source &source) const
+bool View::isSourceSelected(const source &source) const
 {
 	for (auto &sourceId : sourcesIds_) {
 		if (sourceId == source.id) {
diff --git a/src/windows/AppWindow/AppWindow.cpp b/src/windows/AppWindow/AppWindow.cpp
index 19ecdfb..38e2af5 100644
--- a/src/windows/AppWindow/AppWindow.cpp
+++ b/src/windows/AppWindow/AppWindow.cpp
@@ -114,15 +114,15 @@ void AppWindow::setupCallbacks()
 	models().on_get_source_path_from_id([&](int sourceId) {
 		auto source = miraiInstance_->getSourceById(sourceId);
 		assert(source);
-		mirai::MarkdownDataProvider *sourceProvider =
-			dynamic_cast<mirai::MarkdownDataProvider *>(source->dataProvider());
+		mirai::markdown_data_provider *sourceProvider =
+			dynamic_cast<mirai::markdown_data_provider *>(source->data_provider());
 		return slint::SharedString(sourceProvider->path());
 	});
 
-	miraiInstance_->onSourceAdded([&](mirai::Source *source) {
+	miraiInstance_->onSourceAdded([&](mirai::source *source) {
 		refreshModels();
 	});
-	miraiInstance_->onSourceEdited([&](mirai::Source *source) {
+	miraiInstance_->onSourceEdited([&](mirai::source *source) {
 		refreshModels();
 	});
 	miraiInstance_->onSourceDeleted([&](int id) {
@@ -132,7 +132,7 @@ void AppWindow::setupCallbacks()
 	actions().on_task_clicked([&](int sourceId, int taskId) {
 		auto source = miraiInstance_->getSourceById(sourceId);
 		assert(source);
-		auto task = source->getTaskById(taskId);
+		auto task = source->get_task_by_id(taskId);
 		assert(task);
 		if (!task->checked() && !task->hasDate() && !task->hasEvent()) {
 			task->setDate(mirai::Date(mirai::Date(std::chrono::system_clock::now())));
@@ -149,7 +149,7 @@ void AppWindow::setupCallbacks()
 			view_.setAllSources();
 		} else {
 			view_.removeSources();
-			const mirai::Source *source = miraiInstance_->getSourceById(index);
+			const mirai::source *source = miraiInstance_->getSourceById(index);
 			view_.addSource(*source);
 		}
 		models().set_default_source_index(index == -1 ? 0 : index);
@@ -159,8 +159,8 @@ void AppWindow::setupCallbacks()
 	});
 
 	actions().on_add_source([&](slint::SharedString name, slint::SharedString path) {
-		std::unique_ptr<mirai::DataProvider> file =
-			std::make_unique<mirai::MarkdownDataProvider>(std::string(path));
+		std::unique_ptr<mirai::data_provider> file =
+			std::make_unique<mirai::markdown_data_provider>(std::string(path));
 		miraiInstance_->addSource(std::string(name), "FileSystemMarkdown", std::move(file));
 	});
 
@@ -174,9 +174,9 @@ void AppWindow::setupCallbacks()
 	actions().on_delete_task_clicked([&](int sourceId, int taskId) {
 		auto source = miraiInstance_->getSourceById(sourceId);
 		assert(source);
-		auto task = source->getTaskById(taskId);
+		auto task = source->get_task_by_id(taskId);
 		assert(task);
-		source->removeTask(*task);
+		source->remove_task(*task);
 		miraiInstance_->save();
 		view_.update();
 		reloadTasks();
@@ -191,10 +191,10 @@ void AppWindow::setupCallbacks()
 	actions().on_save_task([&](ui::SaveTaskData newTaskData) {
 		auto source = miraiInstance_->getSourceById(newTaskData.sourceId);
 		assert(source);
-		auto task = source->getTaskById(newTaskData.id);
+		auto task = source->get_task_by_id(newTaskData.id);
 		assert(task.has_value());
 		const mirai::Date &date = SlintDateToMiraiDate(newTaskData.date);
-		const auto dayOpt = source->getDayByDate(date);
+		const auto dayOpt = source->get_day_by_date(date);
 		task->setTitle(std::string(newTaskData.title));
 
 		if (!task.value().hasEvent() && date.year != 0) {
@@ -219,10 +219,10 @@ void AppWindow::setupCallbacks()
 
 		std::optional<mirai::Event> event = std::nullopt;
 		if (newTaskData.eventId >= 0) {
-			event = source->getEventById(newTaskData.eventId);
+			event = source->get_event_by_id(newTaskData.eventId);
 		}
 
-		source->createTask({
+		source->create_task({
 			.title = std::string(newTaskData.title),
 			.event = event,
 			.date = date,
@@ -236,9 +236,9 @@ void AppWindow::setupCallbacks()
 	actions().on_delete_event([&](int sourceId, int eventId) {
 		auto source = miraiInstance_->getSourceById(sourceId);
 		assert(source);
-		auto event = source->getEventById(eventId);
+		auto event = source->get_event_by_id(eventId);
 		assert(event.has_value());
-		source->removeEvent(event.value());
+		source->remove_event(event.value());
 		miraiInstance_->save();
 		view_.update();
 		reloadTasks();
@@ -250,7 +250,7 @@ void AppWindow::setupCallbacks()
 		const auto sourceId = models().get_default_source_index();
 		auto source = miraiInstance_->getSourceById(sourceId == -1 ? 0 : sourceId);
 
-		source->createEvent({
+		source->create_event({
 			.title = std::string(newEventParams.title),
 			.date = SlintDateToMiraiDate(newEventParams.date),
 			.startsAt = SlintTimeToMiraiTime(newEventParams.startsAt),
@@ -407,8 +407,8 @@ void AppWindow::reloadSources()
 	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());
+		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()),