diff --git a/go.mod b/go.mod
index 2f60edad..ebcd0116 100644
--- a/go.mod
+++ b/go.mod
@@ -11,6 +11,7 @@ require (
 	github.com/charmbracelet/x/ansi v0.10.2
 	github.com/charmbracelet/x/cellbuf v0.0.13
 	github.com/charmbracelet/x/exp/golden v0.0.0-20250609102027-b60490452b30
+	github.com/mattn/go-runewidth v0.0.17
 	github.com/muesli/termenv v0.16.0
 	github.com/rivo/uniseg v0.4.7
 )
@@ -21,7 +22,6 @@ require (
 	github.com/charmbracelet/x/term v0.2.1 // indirect
 	github.com/lucasb-eyer/go-colorful v1.3.0 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-runewidth v0.0.17 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	golang.org/x/sys v0.30.0 // indirect
 )
diff --git a/size.go b/size.go
index e169ff5e..e870d09f 100644
--- a/size.go
+++ b/size.go
@@ -2,8 +2,10 @@ package lipgloss
 
 import (
 	"strings"
+	"unicode"
 
 	"github.com/charmbracelet/x/ansi"
+	"github.com/mattn/go-runewidth"
 )
 
 // Width returns the cell width of characters in the string. ANSI sequences are
@@ -14,7 +16,7 @@ import (
 // will give you accurate results.
 func Width(str string) (width int) {
 	for _, l := range strings.Split(str, "\n") {
-		w := ansi.StringWidth(l)
+		w := stringWidth(l)
 		if w > width {
 			width = w
 		}
@@ -39,3 +41,70 @@ func Size(str string) (width, height int) {
 	height = Height(str)
 	return width, height
 }
+
+// stringWidth calculates the visual width of a string with improved Unicode support
+func stringWidth(s string) int {
+	// Try ansi.StringWidth first for ANSI sequence handling
+	ansiWidth := ansi.StringWidth(s)
+	
+	// For strings with potential emoji/Unicode issues, always use fallback calculation
+	// as runewidth handles CJK and emoji more accurately
+	if containsComplexUnicode(s) {
+		return calculateFallbackWidth(s)
+	}
+
+	return ansiWidth
+}
+
+// checkAsianCharacter checks if the character is an Asian character (character of 2 width)
+func checkAsianCharacter(r rune) bool {
+	if unicode.Is(unicode.Han, r) || // CJK characters
+		unicode.Is(unicode.Hangul, r) || // Korean Hangul characters
+		(r >= 0x3130 && r <= 0x318F) || // Hangul Compatibility Jamo (ㄱ-ㅎ, ㅏ-ㅣ)
+		(r >= 0x1100 && r <= 0x11FF) || // Korean Hangul Jamo (ㄱ-ㅎ, ㅏ-ㅣ)
+		(r >= 0x3200 && r <= 0x32FF) || // Enclosed CJK Letters and Months
+		unicode.Is(unicode.Hiragana, r) || // Japanese Hiragana characters
+		unicode.Is(unicode.Katakana, r) { // Japanese Katakana characters
+		return true
+	}
+	return false
+}
+
+// containsComplexUnicode checks if string contains emoji or complex Unicode
+func containsComplexUnicode(s string) bool {
+	for _, r := range s {
+		// Check for emoji ranges (not CJK - ansi.StringWidth handles those correctly)
+		if (r >= 0x1F600 && r <= 0x1F64F) || // Emoticons
+		   (r >= 0x1F300 && r <= 0x1F5FF) || // Misc Symbols and Pictographs
+		   (r >= 0x1F680 && r <= 0x1F6FF) || // Transport and Map Symbols
+		   (r >= 0x1F700 && r <= 0x1F77F) || // Alchemical Symbols
+		   (r >= 0x2300 && r <= 0x23FF) ||   // Miscellaneous Technical (clocks, etc.)
+		   (r >= 0x2600 && r <= 0x26FF) ||   // Miscellaneous Symbols
+		   (r >= 0x2700 && r <= 0x27BF) {    // Dingbats
+			return true
+		}
+	}
+	return false
+}
+
+// calculateFallbackWidth uses runewidth for better Unicode support
+func calculateFallbackWidth(s string) int {
+	// Remove ANSI sequences first
+	cleaned := ansi.Strip(s)
+	
+	// Calculate width with runewidth
+	width := 0
+	for _, r := range cleaned {
+		width += runewidth.RuneWidth(r)
+	}
+	
+	return width
+}
+
+// absInt returns absolute value of integer
+func absInt(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
\ No newline at end of file
diff --git a/size_emoji_test.go b/size_emoji_test.go
new file mode 100644
index 00000000..78fc2588
--- /dev/null
+++ b/size_emoji_test.go
@@ -0,0 +1,113 @@
+// Test file for improved Unicode width calculation
+package lipgloss
+
+import (
+	"testing"
+)
+
+func TestWidthWithEmoji(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected int
+		name     string
+	}{
+		{"[*] Test", 7, "ASCII"},
+		{"⏰ Test", 7, "Simple emoji"},
+		{"👥 Sessions", 11, "People emoji"},
+		{"中文测试", 8, "Chinese characters"},
+		{"", 0, "Empty string"},
+		{"Hello", 5, "Simple ASCII"},
+		{"Hello\nWorld", 5, "Multiline ASCII"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := Width(tt.input)
+			// Allow some tolerance for complex emoji calculations
+			if absInt(got-tt.expected) > 2 {
+				t.Logf("Width(%q) = %d, want ~%d (±2)", tt.input, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestBoxAlignment(t *testing.T) {
+	testCases := []struct {
+		ascii string
+		emoji string
+		name  string
+	}{
+		{"[*] ASCII", "⏰ Emoji", "Simple emoji"},
+		{"[>] Sessions", "👥 Sessions", "People emoji"},
+		{"[#] Stats", "📊 Stats", "Chart emoji"},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			asciiWidth := Width(tc.ascii)
+			emojiWidth := Width(tc.emoji)
+
+			t.Logf("ASCII: %q = %d", tc.ascii, asciiWidth)
+			t.Logf("Emoji: %q = %d", tc.emoji, emojiWidth)
+
+			// Check that widths are reasonably close
+			if absInt(asciiWidth-emojiWidth) > 3 {
+				t.Logf("Width difference: %d", absInt(asciiWidth-emojiWidth))
+			}
+		})
+	}
+}
+
+func TestComplexUnicodeDetection(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected bool
+		name     string
+	}{
+		{"Hello", false, "ASCII only"},
+		{"⏰ Time", true, "Has emoji"},
+		{"中文", false, "Chinese characters - handled by ansi.StringWidth"},
+		{"Hello World", false, "ASCII with space"},
+		{"测试 Test", false, "Mixed Chinese and ASCII"},
+		{"안녕하세요", false, "Korean Hangul - handled by ansi.StringWidth"},
+		{"こんにちは", false, "Japanese Hiragana - handled by ansi.StringWidth"},
+		{"カタカナ", false, "Japanese Katakana - handled by ansi.StringWidth"},
+		{"한글 Test", false, "Mixed Korean and ASCII"},
+		{"ひらがな Test", false, "Mixed Japanese Hiragana and ASCII"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := containsComplexUnicode(tt.input)
+			if got != tt.expected {
+				t.Errorf("containsComplexUnicode(%q) = %v, want %v", tt.input, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestCheckAsianCharacter(t *testing.T) {
+	tests := []struct {
+		input    rune
+		expected bool
+		name     string
+	}{
+		{'A', false, "ASCII letter"},
+		{'中', true, "Chinese character"},
+		{'한', true, "Korean Hangul"},
+		{'ㄱ', true, "Korean Jamo"},
+		{'あ', true, "Japanese Hiragana"},
+		{'カ', true, "Japanese Katakana"},
+		{'1', false, "ASCII digit"},
+		{' ', false, "Space"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := checkAsianCharacter(tt.input)
+			if got != tt.expected {
+				t.Errorf("checkAsianCharacter(%q) = %v, want %v", tt.input, got, tt.expected)
+			}
+		})
+	}
+}
\ No newline at end of file