Refactor Init method across all frontends to include argc and argv for improved argument handling consistency.

- Added full UTF-8 support for terminal rendering, including multi-width character handling.
- Improved font handling in ImGui with expanded glyph support (Greek, Mathematical Operators).
- Updated locale initialization to enable proper character rendering.
- Bumped version to 1.5.8.

CMakeLists.txt

@@ -4,7 +4,7 @@ project(kte)
 include(GNUInstallDirs)
 
 set(CMAKE_CXX_STANDARD 20)
-set(KTE_VERSION "1.5.7")
+set(KTE_VERSION "1.5.8")
 
 # Default to terminal-only build to avoid SDL/OpenGL dependency by default.
 # Enable with -DBUILD_GUI=ON when SDL2/OpenGL/Freetype are available.

Frontend.h

@@ -12,7 +12,7 @@ public:
 	virtual ~Frontend() = default;
 
 	// Initialize the frontend (create window/terminal, etc.)
-	virtual bool Init(Editor &ed) = 0;
+	virtual bool Init(int &argc, char **argv, Editor &ed) = 0;
 
 	// Execute one iteration (poll input, dispatch, draw). Set running=false to exit.
 	virtual void Step(Editor &ed, bool &running) = 0;

ImGuiFrontend.cc

@@ -18,6 +18,7 @@
 #include "GUITheme.h"
 #include "fonts/Font.h" // embedded default font (DefaultFont)
 #include "fonts/FontRegistry.h"
+#include "fonts/IosevkaExtended.h"
 #include "syntax/HighlighterRegistry.h"
 #include "syntax/NullHighlighter.h"
 
@@ -29,8 +30,10 @@
 static auto kGlslVersion = "#version 150"; // GL 3.2 core (macOS compatible)
 
 bool
-GUIFrontend::Init(Editor &ed)
+GUIFrontend::Init(int &argc, char **argv, Editor &ed)
 {
+	(void) argc;
+	(void) argv;
 	// Attach editor to input handler for editor-owned features (e.g., universal argument)
 	input_.Attach(&ed);
 	// editor dimensions will be initialized during the first Step() frame
@@ -261,11 +264,11 @@ GUIFrontend::Step(Editor &ed, bool &running)
 
 	// Update editor logical rows/cols using current ImGui metrics and display size
 	{
-		ImGuiIO &io  = ImGui::GetIO();
-		float line_h = ImGui::GetTextLineHeightWithSpacing();
-		float ch_w   = ImGui::CalcTextSize("M").x;
-		if (line_h <= 0.0f)
-			line_h = 16.0f;
+		ImGuiIO &io = ImGui::GetIO();
+		float row_h = ImGui::GetTextLineHeightWithSpacing();
+		float ch_w  = ImGui::CalcTextSize("M").x;
+		if (row_h <= 0.0f)
+			row_h = 16.0f;
 		if (ch_w <= 0.0f)
 			ch_w = 8.0f;
 		// Prefer ImGui IO display size; fall back to cached SDL window size
@@ -273,20 +276,20 @@ GUIFrontend::Step(Editor &ed, bool &running)
 		float disp_h = io.DisplaySize.y > 0 ? io.DisplaySize.y : static_cast<float>(height_);
 
 		// Account for the GUI window padding and the status bar height used in ImGuiRenderer.
-		// ImGuiRenderer pushes WindowPadding = (6,6) every frame, so use the same constants here
-		// to avoid mismatches that would cause premature scrolling.
 		const float pad_x = 6.0f;
 		const float pad_y = 6.0f;
-		// Status bar reserves one frame height (with spacing) inside the window
-		float status_h = ImGui::GetFrameHeightWithSpacing();
 
-		float avail_w = std::max(0.0f, disp_w - 2.0f * pad_x);
-		float avail_h = std::max(0.0f, disp_h - 2.0f * pad_y - status_h);
+		// Use the same logic as ImGuiRenderer for available height and status bar reservation.
+		float wanted_bar_h   = ImGui::GetFrameHeight();
+		float total_avail_h  = std::max(0.0f, disp_h - 2.0f * pad_y);
+		float actual_avail_h = std::floor((total_avail_h - wanted_bar_h) / row_h) * row_h;
 
 		// Visible content rows inside the scroll child
-		auto content_rows = static_cast<std::size_t>(std::floor(avail_h / line_h));
+		auto content_rows = static_cast<std::size_t>(std::max(0.0f, std::floor(actual_avail_h / row_h)));
 		// Editor::Rows includes the status line; add 1 back for it.
-		std::size_t rows = std::max<std::size_t>(1, content_rows + 1);
+		std::size_t rows = content_rows + 1;
+
+		float avail_w    = std::max(0.0f, disp_w - 2.0f * pad_x);
 		std::size_t cols = static_cast<std::size_t>(std::max(1.0f, std::floor(avail_w / ch_w)));
 
 		// Only update if changed to avoid churn
@@ -357,14 +360,32 @@ GUIFrontend::LoadGuiFont_(const char * /*path*/, const float size_px)
 {
 	const ImGuiIO &io = ImGui::GetIO();
 	io.Fonts->Clear();
-	const ImFont *font = io.Fonts->AddFontFromMemoryCompressedTTF(
+
+	ImFontConfig config;
+	config.MergeMode = false;
+
+	// Load Basic Latin + Latin Supplement
+	io.Fonts->AddFontFromMemoryCompressedTTF(
 		kte::Fonts::DefaultFontData,
 		kte::Fonts::DefaultFontSize,
-		size_px);
-	if (!font) {
-		font = io.Fonts->AddFontDefault();
-	}
-	(void) font;
+		size_px,
+		&config,
+		io.Fonts->GetGlyphRangesDefault());
+
+	// Merge Greek and Mathematical symbols from IosevkaExtended
+	config.MergeMode                       = true;
+	static const ImWchar extended_ranges[] = {
+		0x0370, 0x03FF, // Greek and Coptic
+		0x2200, 0x22FF, // Mathematical Operators
+		0,
+	};
+	io.Fonts->AddFontFromMemoryCompressedTTF(
+		kte::Fonts::IosevkaExtended::DefaultFontRegularCompressedData,
+		kte::Fonts::IosevkaExtended::DefaultFontRegularCompressedSize,
+		size_px,
+		&config,
+		extended_ranges);
+
 	io.Fonts->Build();
 	return true;
 }

ImGuiFrontend.h

@@ -17,7 +17,7 @@ public:
 
 	~GUIFrontend() override = default;
 
-	bool Init(Editor &ed) override;
+	bool Init(int &argc, char **argv, Editor &ed) override;
 
 	void Step(Editor &ed, bool &running) override;
 

ImGuiRenderer.cc

@@ -94,8 +94,17 @@ ImGuiRenderer::Draw(Editor &ed)
 			ImGui::SetNextWindowScroll(ImVec2(target_x, target_y));
 		}
 
-		// Reserve space for status bar at bottom
-		ImGui::BeginChild("scroll", ImVec2(0, -ImGui::GetFrameHeightWithSpacing()), false,
+		// Reserve space for status bar at bottom.
+		// We calculate a height that is an exact multiple of the line height
+		// to avoid partial lines and "scroll past end" jitter.
+		float total_avail_h = ImGui::GetContentRegionAvail().y;
+		float wanted_bar_h  = ImGui::GetFrameHeight();
+		float child_h_plan  = std::max(0.0f, std::floor((total_avail_h - wanted_bar_h) / row_h) * row_h);
+		float real_bar_h    = total_avail_h - child_h_plan;
+
+		ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
+		ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
+		ImGui::BeginChild("scroll", ImVec2(0, child_h_plan), false,
 		                  ImGuiWindowFlags_HorizontalScrollbar | ImGuiWindowFlags_NoScrollWithMouse);
 
 		// Get child window position and scroll for click handling
@@ -138,90 +147,6 @@ ImGuiRenderer::Draw(Editor &ed)
 		}
 		prev_buf_rowoffs = buf_rowoffs;
 		prev_buf_coloffs = buf_coloffs;
-
-		// Synchronize cursor and scrolling.
-		// Ensure the cursor is visible, but avoid aggressive centering so that
-		// the same lines remain visible until the cursor actually goes off-screen.
-		{
-			// Compute visible row range using the child window height
-			float child_h  = ImGui::GetWindowHeight();
-			long first_row = static_cast<long>(scroll_y / row_h);
-			long vis_rows  = static_cast<long>(child_h / row_h);
-			if (vis_rows < 1)
-				vis_rows = 1;
-			long last_row = first_row + vis_rows - 1;
-
-			long cyr = static_cast<long>(cy);
-			if (cyr < first_row) {
-				// Scroll just enough to bring the cursor line to the top
-				float target = static_cast<float>(cyr) * row_h;
-				if (target < 0.f)
-					target = 0.f;
-				float max_y = ImGui::GetScrollMaxY();
-				if (max_y >= 0.f && target > max_y)
-					target = max_y;
-				ImGui::SetScrollY(target);
-				scroll_y  = ImGui::GetScrollY();
-				first_row = static_cast<long>(scroll_y / row_h);
-				last_row  = first_row + vis_rows - 1;
-			} else if (cyr > last_row) {
-				// Scroll just enough to bring the cursor line to the bottom
-				long new_first = cyr - vis_rows + 1;
-				if (new_first < 0)
-					new_first = 0;
-				float target = static_cast<float>(new_first) * row_h;
-				float max_y  = ImGui::GetScrollMaxY();
-				if (target < 0.f)
-					target = 0.f;
-				if (max_y >= 0.f && target > max_y)
-					target = max_y;
-				ImGui::SetScrollY(target);
-				scroll_y  = ImGui::GetScrollY();
-				first_row = static_cast<long>(scroll_y / row_h);
-				last_row  = first_row + vis_rows - 1;
-			}
-
-			// Horizontal scroll: ensure cursor column is visible
-			float child_w = ImGui::GetWindowWidth();
-			long vis_cols = static_cast<long>(child_w / space_w);
-			if (vis_cols < 1)
-				vis_cols = 1;
-			long first_col = static_cast<long>(scroll_x / space_w);
-			long last_col  = first_col + vis_cols - 1;
-
-			// Compute cursor's rendered X position (accounting for tabs)
-			std::size_t cursor_rx = 0;
-			if (cy < lines.size()) {
-				std::string cur_line   = static_cast<std::string>(lines[cy]);
-				const std::size_t tabw = 8;
-				for (std::size_t i = 0; i < cx && i < cur_line.size(); ++i) {
-					if (cur_line[i] == '\t') {
-						cursor_rx += tabw - (cursor_rx % tabw);
-					} else {
-						cursor_rx += 1;
-					}
-				}
-			}
-			long cxr = static_cast<long>(cursor_rx);
-			if (cxr < first_col || cxr > last_col) {
-				float target_x = static_cast<float>(cxr) * space_w;
-				// Center horizontally if possible
-				target_x -= (child_w / 2.0f);
-				if (target_x < 0.f)
-					target_x = 0.f;
-				float max_x = ImGui::GetScrollMaxX();
-				if (max_x >= 0.f && target_x > max_x)
-					target_x = max_x;
-				ImGui::SetScrollX(target_x);
-				scroll_x = ImGui::GetScrollX();
-			}
-			// Phase 3: prefetch visible viewport highlights and warm around in background
-			if (buf->SyntaxEnabled() && buf->Highlighter() && buf->Highlighter()->HasHighlighter()) {
-				int fr = static_cast<int>(std::max(0L, first_row));
-				int rc = static_cast<int>(std::max(1L, vis_rows));
-				buf->Highlighter()->PrefetchViewport(*buf, fr, rc, buf->Version());
-			}
-		}
 		// Cache current horizontal offset in rendered columns for click handling
 		const std::size_t coloffs_now = buf->Coloffs();
 
@@ -489,23 +414,98 @@ ImGuiRenderer::Draw(Editor &ed)
 				ImGui::GetWindowDrawList()->AddRectFilled(p0, p1, col);
 			}
 		}
+		// Synchronize cursor and scrolling after rendering all lines so content size is known.
+		{
+			float child_h_actual = ImGui::GetWindowHeight();
+			float child_w_actual = ImGui::GetWindowWidth();
+			float scroll_y_now   = ImGui::GetScrollY();
+			float scroll_x_now   = ImGui::GetScrollX();
+
+			long first_row = static_cast<long>(scroll_y_now / row_h);
+			long vis_rows  = static_cast<long>(std::round(child_h_actual / row_h));
+			if (vis_rows < 1)
+				vis_rows = 1;
+			long last_row = first_row + vis_rows - 1;
+
+			long cyr = static_cast<long>(cy);
+			if (cyr < first_row) {
+				float target = static_cast<float>(cyr) * row_h;
+				if (target < 0.f)
+					target = 0.f;
+				float max_y = ImGui::GetScrollMaxY();
+				if (max_y >= 0.f && target > max_y)
+					target = max_y;
+				ImGui::SetScrollY(target);
+				first_row = static_cast<long>(target / row_h);
+				last_row  = first_row + vis_rows - 1;
+			} else if (cyr > last_row) {
+				long new_first = cyr - vis_rows + 1;
+				if (new_first < 0)
+					new_first = 0;
+				float target = static_cast<float>(new_first) * row_h;
+				float max_y  = ImGui::GetScrollMaxY();
+				if (target < 0.f)
+					target = 0.f;
+				if (max_y >= 0.f && target > max_y)
+					target = max_y;
+				ImGui::SetScrollY(target);
+				first_row = static_cast<long>(target / row_h);
+				last_row  = first_row + vis_rows - 1;
+			}
+
+			// Horizontal scroll: ensure cursor column is visible
+			long vis_cols = static_cast<long>(std::round(child_w_actual / space_w));
+			if (vis_cols < 1)
+				vis_cols = 1;
+			long first_col = static_cast<long>(scroll_x_now / space_w);
+			long last_col  = first_col + vis_cols - 1;
+
+			std::size_t cursor_rx = 0;
+			if (cy < lines.size()) {
+				std::string cur_line   = static_cast<std::string>(lines[cy]);
+				const std::size_t tabw = 8;
+				for (std::size_t i = 0; i < cx && i < cur_line.size(); ++i) {
+					if (cur_line[i] == '\t') {
+						cursor_rx += tabw - (cursor_rx % tabw);
+					} else {
+						cursor_rx += 1;
+					}
+				}
+			}
+			long cxr = static_cast<long>(cursor_rx);
+			if (cxr < first_col || cxr > last_col) {
+				float target_x = static_cast<float>(cxr) * space_w;
+				target_x       -= (child_w_actual / 2.0f);
+				if (target_x < 0.f)
+					target_x = 0.f;
+				float max_x = ImGui::GetScrollMaxX();
+				if (max_x >= 0.f && target_x > max_x)
+					target_x = max_x;
+				ImGui::SetScrollX(target_x);
+			}
+
+			if (buf->SyntaxEnabled() && buf->Highlighter() && buf->Highlighter()->HasHighlighter()) {
+				int fr = static_cast<int>(std::max(0L, first_row));
+				int rc = static_cast<int>(std::max(1L, vis_rows));
+				buf->Highlighter()->PrefetchViewport(*buf, fr, rc, buf->Version());
+			}
+		}
 		ImGui::EndChild();
+		ImGui::PopStyleVar(2); // WindowPadding, ItemSpacing
 
-		// Status bar spanning full width
-		ImGui::Separator();
-
-		// Compute full content width and draw a filled background rectangle
+		// Status bar area starting right after the scroll child
 		ImVec2 win_pos = ImGui::GetWindowPos();
-		ImVec2 cr_min  = ImGui::GetWindowContentRegionMin();
-		ImVec2 cr_max  = ImGui::GetWindowContentRegionMax();
-		float x0       = win_pos.x + cr_min.x;
-		float x1       = win_pos.x + cr_max.x;
-		ImVec2 cursor  = ImGui::GetCursorScreenPos();
-		float bar_h    = ImGui::GetFrameHeight();
-		ImVec2 p0(x0, cursor.y);
-		ImVec2 p1(x1, cursor.y + bar_h);
+		ImVec2 win_sz  = ImGui::GetWindowSize();
+		float x0       = win_pos.x;
+		float x1       = win_pos.x + win_sz.x;
+		float y0       = ImGui::GetCursorScreenPos().y;
+		float bar_h    = real_bar_h;
+
+		ImVec2 p0(x0, y0);
+		ImVec2 p1(x1, y0 + bar_h);
 		ImU32 bg_col = ImGui::GetColorU32(ImGuiCol_HeaderActive);
 		ImGui::GetWindowDrawList()->AddRectFilled(p0, p1, bg_col);
+
 		// If a prompt is active, replace the entire status bar with the prompt text
 		if (ed.PromptActive()) {
 			std::string label = ed.PromptLabel();
@@ -560,7 +560,7 @@ ImGuiRenderer::Draw(Editor &ed)
 								              (size_t) std::max<size_t>(
 									              1, (size_t) (tail.size() / 4)))
 							              : 1;
-						start += skip;
+						start                 += skip;
 						std::string candidate = tail.substr(start);
 						ImVec2 cand_sz        = ImGui::CalcTextSize(candidate.c_str());
 						if (cand_sz.x <= avail_px) {
@@ -591,11 +591,9 @@ ImGuiRenderer::Draw(Editor &ed)
 
 			ImVec2 msg_sz = ImGui::CalcTextSize(final_msg.c_str());
 			ImGui::PushClipRect(ImVec2(p0.x, p0.y), ImVec2(p1.x, p1.y), true);
-			ImGui::SetCursorScreenPos(ImVec2(left_x, p0.y + (bar_h - msg_sz.y) * 0.5f));
+			ImGui::SetCursorScreenPos(ImVec2(left_x, y0 + (bar_h - msg_sz.y) * 0.5f));
 			ImGui::TextUnformatted(final_msg.c_str());
 			ImGui::PopClipRect();
-			// Advance cursor to after the bar to keep layout consistent
-			ImGui::Dummy(ImVec2(x1 - x0, bar_h));
 		} else {
 			// Build left text
 			std::string left;
@@ -618,11 +616,11 @@ ImGuiRenderer::Draw(Editor &ed)
 				std::size_t total = ed.BufferCount();
 				if (total > 0) {
 					std::size_t idx1 = ed.CurrentBufferIndex() + 1; // 1-based for display
-					left += "[";
-					left += std::to_string(static_cast<unsigned long long>(idx1));
-					left += "/";
-					left += std::to_string(static_cast<unsigned long long>(total));
-					left += "] ";
+					left             += "[";
+					left             += std::to_string(static_cast<unsigned long long>(idx1));
+					left             += "/";
+					left             += std::to_string(static_cast<unsigned long long>(total));
+					left             += "] ";
 				}
 			}
 			left += fname;
@@ -631,9 +629,9 @@ ImGuiRenderer::Draw(Editor &ed)
 			// Append total line count as "<n>L"
 			{
 				unsigned long lcount = static_cast<unsigned long>(buf->Rows().size());
-				left += " ";
-				left += std::to_string(lcount);
-				left += "L";
+				left                 += " ";
+				left                 += std::to_string(lcount);
+				left                 += "L";
 			}
 
 			// Build right text (cursor/mark)
@@ -671,20 +669,21 @@ ImGuiRenderer::Draw(Editor &ed)
 				float max_left = std::max(0.0f, right_x - left_x - pad);
 				if (max_left < left_sz.x && max_left > 10.0f) {
 					// Render a clipped left using a child region
-					ImGui::SetCursorScreenPos(ImVec2(left_x, p0.y + (bar_h - left_sz.y) * 0.5f));
-					ImGui::PushClipRect(ImVec2(left_x, p0.y), ImVec2(right_x - pad, p1.y), true);
+					ImGui::SetCursorScreenPos(ImVec2(left_x, y0 + (bar_h - left_sz.y) * 0.5f));
+					ImGui::PushClipRect(ImVec2(left_x, y0), ImVec2(right_x - pad, y0 + bar_h),
+					                    true);
 					ImGui::TextUnformatted(left.c_str());
 					ImGui::PopClipRect();
 				}
 			} else {
 				// Draw left normally
-				ImGui::SetCursorScreenPos(ImVec2(left_x, p0.y + (bar_h - left_sz.y) * 0.5f));
+				ImGui::SetCursorScreenPos(ImVec2(left_x, y0 + (bar_h - left_sz.y) * 0.5f));
 				ImGui::TextUnformatted(left.c_str());
 			}
 
 			// Draw right
 			ImGui::SetCursorScreenPos(ImVec2(std::max(right_x, left_x),
-			                                 p0.y + (bar_h - right_sz.y) * 0.5f));
+			                                 y0 + (bar_h - right_sz.y) * 0.5f));
 			ImGui::TextUnformatted(right.c_str());
 
 			// Draw middle message centered in remaining space
@@ -696,14 +695,12 @@ ImGuiRenderer::Draw(Editor &ed)
 					ImVec2 msg_sz = ImGui::CalcTextSize(msg.c_str());
 					float msg_x   = mid_left + std::max(0.0f, (mid_w - msg_sz.x) * 0.5f);
 					// Clip to middle region
-					ImGui::PushClipRect(ImVec2(mid_left, p0.y), ImVec2(mid_right, p1.y), true);
-					ImGui::SetCursorScreenPos(ImVec2(msg_x, p0.y + (bar_h - msg_sz.y) * 0.5f));
+					ImGui::PushClipRect(ImVec2(mid_left, y0), ImVec2(mid_right, y0 + bar_h), true);
+					ImGui::SetCursorScreenPos(ImVec2(msg_x, y0 + (bar_h - msg_sz.y) * 0.5f));
 					ImGui::TextUnformatted(msg.c_str());
 					ImGui::PopClipRect();
 				}
 			}
-			// Advance cursor to after the bar to keep layout consistent
-			ImGui::Dummy(ImVec2(x1 - x0, bar_h));
 		}
 	}
 

QtFrontend.cc

@@ -142,13 +142,13 @@ protected:
 				p.save();
 				p.setClipRect(viewport);
 
-    // Iterate visible lines
-    for (std::size_t i = rowoffs, vis_idx = 0; i < last_row; ++i, ++vis_idx) {
-        // Materialize the Buffer::Line into a std::string for
-        // regex/iterator usage and general string ops.
-        const std::string line = static_cast<std::string>(lines[i]);
-					const int y        = viewport.y() + static_cast<int>(vis_idx) * line_h;
-					const int baseline = y + fm.ascent();
+				// Iterate visible lines
+				for (std::size_t i = rowoffs, vis_idx = 0; i < last_row; ++i, ++vis_idx) {
+					// Materialize the Buffer::Line into a std::string for
+					// regex/iterator usage and general string ops.
+					const std::string line = static_cast<std::string>(lines[i]);
+					const int y            = viewport.y() + static_cast<int>(vis_idx) * line_h;
+					const int baseline     = y + fm.ascent();
 
 					// Helper: convert src col -> rx with tab expansion
 					auto src_to_rx_line = [&](std::size_t src_col) -> std::size_t {
@@ -453,11 +453,11 @@ protected:
 					std::size_t total = ed_->BufferCount();
 					if (total > 0) {
 						std::size_t idx1 = ed_->CurrentBufferIndex() + 1; // 1-based
-						left += QStringLiteral("  [");
-						left += QString::number(static_cast<qlonglong>(idx1));
-						left += QStringLiteral("/");
-						left += QString::number(static_cast<qlonglong>(total));
-						left += QStringLiteral("] ");
+						left             += QStringLiteral("  [");
+						left             += QString::number(static_cast<qlonglong>(idx1));
+						left             += QStringLiteral("/");
+						left             += QString::number(static_cast<qlonglong>(total));
+						left             += QStringLiteral("] ");
 					} else {
 						left += QStringLiteral("  ");
 					}
@@ -477,9 +477,9 @@ protected:
 
 					// total lines suffix " <n>L"
 					unsigned long lcount = static_cast<unsigned long>(buf->Rows().size());
-					left += QStringLiteral(" ");
-					left += QString::number(static_cast<qlonglong>(lcount));
-					left += QStringLiteral("L");
+					left                 += QStringLiteral(" ");
+					left                 += QString::number(static_cast<qlonglong>(lcount));
+					left                 += QStringLiteral("L");
 				}
 
 				// Build right segment: cursor and mark
@@ -602,12 +602,12 @@ protected:
 		int d_cols = 0;
 		if (std::fabs(v_scroll_accum_) >= 1.0 && (!horiz_mode || std::fabs(v_scroll_accum_) > std::fabs(
 			                                          h_scroll_accum_))) {
-			d_rows = static_cast<int>(v_scroll_accum_);
+			d_rows          = static_cast<int>(v_scroll_accum_);
 			v_scroll_accum_ -= d_rows;
 		}
 		if (std::fabs(h_scroll_accum_) >= 1.0 && (horiz_mode || std::fabs(h_scroll_accum_) >= std::fabs(
 			                                          v_scroll_accum_))) {
-			d_cols = static_cast<int>(h_scroll_accum_);
+			d_cols          = static_cast<int>(h_scroll_accum_);
 			h_scroll_accum_ -= d_cols;
 		}
 
@@ -658,11 +658,9 @@ private:
 } // namespace
 
 bool
-GUIFrontend::Init(Editor &ed)
+GUIFrontend::Init(int &argc, char **argv, Editor &ed)
 {
-	int argc    = 0;
-	char **argv = nullptr;
-	app_        = new QApplication(argc, argv);
+	app_ = new QApplication(argc, argv);
 
 	window_ = new MainWindow(input_);
 	window_->show();

QtFrontend.h

@@ -18,7 +18,7 @@ public:
 
 	~GUIFrontend() override = default;
 
-	bool Init(Editor &ed) override;
+	bool Init(int &argc, char **argv, Editor &ed) override;
 
 	void Step(Editor &ed, bool &running) override;
 

TerminalFrontend.cc

@@ -8,8 +8,10 @@
 
 
 bool
-TerminalFrontend::Init(Editor &ed)
+TerminalFrontend::Init(int &argc, char **argv, Editor &ed)
 {
+	(void) argc;
+	(void) argv;
 	// Ensure Control keys reach the app: disable XON/XOFF and dsusp/susp bindings (e.g., ^S/^Q, ^Y on macOS)
 	{
 		struct termios tio{};

TerminalFrontend.h

@@ -21,7 +21,7 @@ public:
 	// Adjust if your terminal needs a different threshold.
 	static constexpr int kEscDelayMs = 50;
 
-	bool Init(Editor &ed) override;
+	bool Init(int &argc, char **argv, Editor &ed) override;
 
 	void Step(Editor &ed, bool &running) override;
 

TerminalRenderer.cc

@@ -1,3 +1,6 @@
+#include <clocale>
+#define _XOPEN_SOURCE_EXTENDED 1
+#include <cwchar>
 #include <algorithm>
 #include <cstdio>
 #include <filesystem>
@@ -157,35 +160,52 @@ TerminalRenderer::Draw(Editor &ed)
 					// Map to simple attributes; search highlight uses A_STANDOUT which takes precedence below
 					attrset(A_NORMAL);
 					switch (k) {
-						case kte::TokenKind::Keyword:
-						case kte::TokenKind::Type:
-						case kte::TokenKind::Constant:
-						case kte::TokenKind::Function:
-							attron(A_BOLD);
-							break;
-						case kte::TokenKind::Comment:
-							attron(A_DIM);
-							break;
-						case kte::TokenKind::String:
-						case kte::TokenKind::Char:
-						case kte::TokenKind::Number:
-							// standout a bit using A_UNDERLINE if available
-							attron(A_UNDERLINE);
-							break;
-						default:
-							break;
+					case kte::TokenKind::Keyword:
+					case kte::TokenKind::Type:
+					case kte::TokenKind::Constant:
+					case kte::TokenKind::Function:
+						attron(A_BOLD);
+						break;
+					case kte::TokenKind::Comment:
+						attron(A_DIM);
+						break;
+					case kte::TokenKind::String:
+					case kte::TokenKind::Char:
+					case kte::TokenKind::Number:
+						// standout a bit using A_UNDERLINE if available
+						attron(A_UNDERLINE);
+						break;
+					default:
+						break;
 					}
 				};
 				while (written < cols) {
-					char ch       = ' ';
 					bool from_src = false;
+					wchar_t wch   = L' ';
+					int wch_len   = 1;
+					int disp_w    = 1;
+
 					if (src_i < line.size()) {
-						unsigned char c = static_cast<unsigned char>(line[src_i]);
-						if (c == '\t') {
+						// Decode UTF-8
+						std::mbstate_t state = std::mbstate_t();
+						size_t res           = std::mbrtowc(
+							&wch, &line[src_i], line.size() - src_i, &state);
+						if (res == (size_t) -1 || res == (size_t) -2) {
+							// Invalid or incomplete; treat as single byte
+							wch     = static_cast<unsigned char>(line[src_i]);
+							wch_len = 1;
+						} else if (res == 0) {
+							wch     = L'\0';
+							wch_len = 1;
+						} else {
+							wch_len = static_cast<int>(res);
+						}
+
+						if (wch == L'\t') {
 							std::size_t next_tab = tabw - (render_col % tabw);
 							if (render_col + next_tab <= coloffs) {
 								render_col += next_tab;
-								++src_i;
+								src_i      += wch_len;
 								continue;
 							}
 							// Emit spaces for tab
@@ -194,7 +214,7 @@ TerminalRenderer::Draw(Editor &ed)
 								std::size_t to_skip = std::min<std::size_t>(
 									next_tab, coloffs - render_col);
 								render_col += to_skip;
-								next_tab -= to_skip;
+								next_tab   -= to_skip;
 							}
 							// Now render visible spaces
 							while (next_tab > 0 && written < cols) {
@@ -233,23 +253,34 @@ TerminalRenderer::Draw(Editor &ed)
 								++render_col;
 								--next_tab;
 							}
-							++src_i;
+							src_i += wch_len;
 							continue;
 						} else {
 							// normal char
+							disp_w = wcwidth(wch);
+							if (disp_w < 0)
+								disp_w = 1; // non-printable or similar
+
 							if (render_col < coloffs) {
-								++render_col;
-								++src_i;
+								render_col += disp_w;
+								src_i      += wch_len;
 								continue;
 							}
-							ch       = static_cast<char>(c);
 							from_src = true;
 						}
 					} else {
 						// beyond EOL, fill spaces
-						ch       = ' ';
+						wch      = L' ';
+						wch_len  = 1;
+						disp_w   = 1;
 						from_src = false;
 					}
+
+					if (written + disp_w > cols) {
+						// would overflow, just break
+						break;
+					}
+
 					bool in_hl  = search_mode && from_src && is_src_in_hl(src_i);
 					bool in_cur =
 						has_current && li == cur_my && from_src && src_i >= cur_mx && src_i <
@@ -273,11 +304,20 @@ TerminalRenderer::Draw(Editor &ed)
 					if (!in_hl && from_src) {
 						apply_token_attr(token_at(src_i));
 					}
-					addch(static_cast<unsigned char>(ch));
-					++written;
-					++render_col;
+
+					if (from_src) {
+						cchar_t cch;
+						wchar_t warr[2] = {wch, L'\0'};
+						setcchar(&cch, warr, A_NORMAL, 0, nullptr);
+						add_wch(&cch);
+					} else {
+						addch(' ');
+					}
+
+					written    += disp_w;
+					render_col += disp_w;
 					if (from_src)
-						++src_i;
+						src_i += wch_len;
 					if (src_i >= line.size() && written >= cols)
 						break;
 				}
@@ -297,23 +337,35 @@ TerminalRenderer::Draw(Editor &ed)
 		// Place terminal cursor at logical position accounting for tabs and coloffs.
 		// Recompute the rendered X using the same logic as the drawing loop to avoid
 		// any drift between the command-layer computation and the terminal renderer.
-		std::size_t cy = buf->Cury();
-		std::size_t cx = buf->Curx();
-		int cur_y = static_cast<int>(cy) - static_cast<int>(buf->Rowoffs());
+		std::size_t cy            = buf->Cury();
+		std::size_t cx            = buf->Curx();
+		int cur_y                 = static_cast<int>(cy) - static_cast<int>(buf->Rowoffs());
 		std::size_t rx_recomputed = 0;
 		if (cy < lines.size()) {
 			const std::string line_for_cursor = static_cast<std::string>(lines[cy]);
-			std::size_t src_i_cur = 0;
-			std::size_t render_col_cur = 0;
+			std::size_t src_i_cur             = 0;
+			std::size_t render_col_cur        = 0;
 			while (src_i_cur < line_for_cursor.size() && src_i_cur < cx) {
-				unsigned char ccur = static_cast<unsigned char>(line_for_cursor[src_i_cur]);
-				if (ccur == '\t') {
-					std::size_t next_tab = tabw - (render_col_cur % tabw);
-					render_col_cur += next_tab;
-					++src_i_cur;
+				std::mbstate_t state = std::mbstate_t();
+				wchar_t wch;
+				size_t res = std::mbrtowc(
+					&wch, &line_for_cursor[src_i_cur], line_for_cursor.size() - src_i_cur,
+					&state);
+
+				if (res == (size_t) -1 || res == (size_t) -2) {
+					render_col_cur += 1;
+					src_i_cur      += 1;
+				} else if (res == 0) {
+					src_i_cur += 1;
 				} else {
-					++render_col_cur;
-					++src_i_cur;
+					if (wch == L'\t') {
+						std::size_t next_tab = tabw - (render_col_cur % tabw);
+						render_col_cur       += next_tab;
+					} else {
+						int dw         = wcwidth(wch);
+						render_col_cur += (dw < 0) ? 1 : dw;
+					}
+					src_i_cur += res;
 				}
 			}
 			rx_recomputed = render_col_cur;
@@ -403,9 +455,9 @@ TerminalRenderer::Draw(Editor &ed)
 	{
 		const char *app = "kte";
 		left.reserve(256);
-		left += app;
-		left += " ";
-		left += KTE_VERSION_STR; // already includes leading 'v'
+		left            += app;
+		left            += " ";
+		left            += KTE_VERSION_STR; // already includes leading 'v'
 		const Buffer *b = buf;
 		std::string fname;
 		if (b) {
@@ -426,11 +478,11 @@ TerminalRenderer::Draw(Editor &ed)
 			std::size_t total = ed.BufferCount();
 			if (total > 0) {
 				std::size_t idx1 = ed.CurrentBufferIndex() + 1; // human-friendly 1-based
-				left += "[";
-				left += std::to_string(static_cast<unsigned long long>(idx1));
-				left += "/";
-				left += std::to_string(static_cast<unsigned long long>(total));
-				left += "] ";
+				left             += "[";
+				left             += std::to_string(static_cast<unsigned long long>(idx1));
+				left             += "/";
+				left             += std::to_string(static_cast<unsigned long long>(total));
+				left             += "] ";
 			}
 		}
 		left += fname;
@@ -442,9 +494,9 @@ TerminalRenderer::Draw(Editor &ed)
 		// Append total line count as "<n>L"
 		if (b) {
 			unsigned long lcount = static_cast<unsigned long>(b->Rows().size());
-			left += " ";
-			left += std::to_string(lcount);
-			left += "L";
+			left                 += " ";
+			left                 += std::to_string(lcount);
+			left                 += "L";
 		}
 	}
 

TestFrontend.cc

@@ -4,8 +4,10 @@
 
 
 bool
-TestFrontend::Init(Editor &ed)
+TestFrontend::Init(int &argc, char **argv, Editor &ed)
 {
+	(void) argc;
+	(void) argv;
 	ed.SetDimensions(24, 80);
 	return true;
 }

TestFrontend.h

@@ -13,7 +13,7 @@ public:
 
 	~TestFrontend() override = default;
 
-	bool Init(Editor &ed) override;
+	bool Init(int &argc, char **argv, Editor &ed) override;
 
 	void Step(Editor &ed, bool &running) override;
 

fonts/Font.cc

@@ -1,4 +1,5 @@
 #include "Font.h"
+#include "IosevkaExtended.h"
 
 #include "imgui.h"
 
@@ -8,16 +9,32 @@ Font::Load(const float size) const
 {
 	const ImGuiIO &io = ImGui::GetIO();
 	io.Fonts->Clear();
-	const ImFont *font = io.Fonts->AddFontFromMemoryCompressedTTF(
+
+	ImFontConfig config;
+	config.MergeMode = false;
+
+	// Load Basic Latin + Latin Supplement
+	io.Fonts->AddFontFromMemoryCompressedTTF(
 		this->data_,
 		this->size_,
-		size);
+		size,
+		&config,
+		io.Fonts->GetGlyphRangesDefault());
 
-	if (!font) {
-		font = io.Fonts->AddFontDefault();
-	}
+	// Merge Greek and Mathematical symbols from IosevkaExtended as fallback
+	config.MergeMode                       = true;
+	static const ImWchar extended_ranges[] = {
+		0x0370, 0x03FF, // Greek and Coptic
+		0x2200, 0x22FF, // Mathematical Operators
+		0,
+	};
+	io.Fonts->AddFontFromMemoryCompressedTTF(
+		kte::Fonts::IosevkaExtended::DefaultFontRegularCompressedData,
+		kte::Fonts::IosevkaExtended::DefaultFontRegularCompressedSize,
+		size,
+		&config,
+		extended_ranges);
 
-	(void) font;
 	io.Fonts->Build();
 }
 } // namespace kte::Fonts

main.cc

@@ -1,3 +1,4 @@
+#include <clocale>
 #include <cctype>
 #include <cerrno>
 #include <cstdio>
@@ -111,8 +112,10 @@ RunStressHighlighter(unsigned seconds)
 
 
 int
-main(int argc, const char *argv[])
+main(int argc, char *argv[])
 {
+	std::setlocale(LC_ALL, "");
+
 	Editor editor;
 
 	// CLI parsing using getopt_long
@@ -133,7 +136,7 @@ main(int argc, const char *argv[])
 	int opt;
 	int long_index          = 0;
 	unsigned stress_seconds = 0;
-	while ((opt = getopt_long(argc, const_cast<char *const *>(argv), "gthV", long_opts, &long_index)) != -1) {
+	while ((opt = getopt_long(argc, argv, "gthV", long_opts, &long_index)) != -1) {
 		switch (opt) {
 		case 'g':
 			req_gui = true;
@@ -300,7 +303,7 @@ main(int argc, const char *argv[])
 	}
 #endif
 
-	if (!fe->Init(editor)) {
+	if (!fe->Init(argc, argv, editor)) {
 		std::cerr << "kte: failed to initialize frontend" << std::endl;
 		return 1;
 	}