diff --git a/core/encoding/base64/base64.odin b/core/encoding/base64/base64.odin
index c1e2b6832..de764139d 100644
--- a/core/encoding/base64/base64.odin
+++ b/core/encoding/base64/base64.odin
@@ -533,5 +533,5 @@ decoded_len :: proc(data: string) -> int {
 		}
 	}
 
-	return ((length * 6) >> 3) - padding
+	return max(0, ((length * 6) >> 3) - padding)
 }
diff --git a/tests/issues/run.bat b/tests/issues/run.bat
index 62bd60b2a..f31f67a80 100644
--- a/tests/issues/run.bat
+++ b/tests/issues/run.bat
@@ -102,6 +102,7 @@ clang -c ..\test_issue_sysv_abi.c -o test_issue_sysv_abi_c.o || exit /b
 ..\..\..\odin test ..\test_issue_equal_proc_dependencies.odin %COMMON% -build-mode:obj 2>&1 | find /i /c "missing procedure" | findstr /x "0" || exit /b
 ..\..\..\odin test ..\test_issue_7779.odin %COMMON% || exit /b
 ..\..\..\odin run ..\test_issue_7798.odin %COMMON% || exit /b
+..\..\..\odin test ..\test_issue_7763.odin %COMMON% || exit /b
 
 @echo off
 
diff --git a/tests/issues/run.sh b/tests/issues/run.sh
index d9432242f..0bc5e1e18 100755
--- a/tests/issues/run.sh
+++ b/tests/issues/run.sh
@@ -264,6 +264,7 @@ $ODIN test ../test_issue_7547.odin $COMMON
 $ODIN test ../test_issue_7490.odin $COMMON
 $ODIN test ../test_issue_7779.odin $COMMON
 $ODIN run ../test_issue_7798.odin $COMMON
+$ODIN test ../test_issue_7763.odin $COMMON
 
 set +x
 
diff --git a/tests/issues/test_issue_7763.odin b/tests/issues/test_issue_7763.odin
new file mode 100644
index 000000000..ace7b9956
--- /dev/null
+++ b/tests/issues/test_issue_7763.odin
@@ -0,0 +1,210 @@
+package test_issues
+
+import "core:testing"
+import "core:encoding/base64"
+import "core:slice"
+
+main :: proc() {
+	t: testing.T
+	test_issue_7763__1eq(&t)
+}
+
+@(test)
+test_issue_7763__nothing :: proc(t: ^testing.T) {
+	input := ""
+	decoded, err := base64.decode(input)
+	testing.expect(t, err == nil)
+	testing.expect(t, decoded == nil)
+}
+
+@(test)
+test_issue_7763__1eq :: proc(t: ^testing.T) {
+	input := "="
+	decoded, err := base64.decode(input)
+	testing.expect(t, err == nil)
+	testing.expect(t, decoded == nil)
+}
+
+@(test)
+test_issue_7763__2eq :: proc(t: ^testing.T) {
+	input := "=="
+	decoded, err := base64.decode(input)
+	testing.expect(t, err == nil)
+	testing.expect(t, decoded == nil)
+}
+
+@(test)
+test_issue_7763__3eq :: proc(t: ^testing.T) {
+	input := "==="
+	decoded, err := base64.decode(input)
+	testing.expect(t, err == nil)
+	testing.expect(t, decoded == nil)
+}
+
+@(test)
+test_issue_7763__4eq :: proc(t: ^testing.T) {
+	input := "===="
+	decoded, err := base64.decode(input)
+	// TODO: Either this should just work, or we should get Invalid_Padding, no? Currently gives Invalid_Character.
+	// TODO: Same for 5+ padding chars.
+	testing.expect(t, err != nil)
+	testing.expect(t, decoded == nil)
+}
+
+@(test)
+test_issue_7763__Aeq :: proc(t: ^testing.T) {
+	input := "A="
+	decoded, err := base64.decode(input)
+	testing.expect(t, err == nil)
+	testing.expect(t, decoded == nil)
+}
+
+@(test)
+test_issue_7763__QQ :: proc(t: ^testing.T) {
+	input := "QQ"
+	decoded, err := base64.decode(input)
+	testing.expect(t, err == nil)
+	testing.expect(t, slice.equal(decoded, { 'A' }))
+	delete(decoded)
+}
+
+@(test)
+test_issue_7763__QQ1eq :: proc(t: ^testing.T) {
+	input := "QQ="
+	decoded, err := base64.decode(input)
+	testing.expect(t, err == nil)
+	testing.expect(t, slice.equal(decoded, { 'A' }))
+	delete(decoded)
+}
+
+@(test)
+test_issue_7763__QQ2eq :: proc(t: ^testing.T) {
+	input := "QQ=="
+	decoded, err := base64.decode(input)
+	testing.expect(t, err == nil)
+	testing.expect(t, slice.equal(decoded, { 'A' }))
+	delete(decoded)
+}
+
+@(test)
+test_issue_7763__QQ3eq :: proc(t: ^testing.T) {
+	input := "QQ==="
+	decoded, err := base64.decode(input)
+	testing.expect(t, err == nil)
+	testing.expect(t, slice.equal(decoded, { 'A' }))
+	delete(decoded)
+}
+
+@(test)
+test_issue_7763__QQ4eq :: proc(t: ^testing.T) {
+	input := "QQ===="
+	decoded, err := base64.decode(input)
+	// TODO: Either this should just work, or we should get Invalid_Padding, no? Currently gives Invalid_Character.
+	testing.expect(t, err != nil)
+	testing.expect(t, decoded == nil)
+}
+
+@(test)
+test_issue_7763__QQ6eq :: proc(t: ^testing.T) {
+	input := "QQ======"
+	decoded, err := base64.decode(input)
+	// TODO: Either this should just work, or we should get Invalid_Padding, no? Currently gives Invalid_Character.
+	testing.expect(t, err != nil)
+	testing.expect(t, decoded == nil)
+}
+
+// Strict
+
+@(test)
+test_issue_7763__strict_1eq :: proc(t: ^testing.T) {
+	input := "="
+	decoded, err := base64.decode(input, options = { .Strict })
+	testing.expect_value(t, err, .Invalid_Padding)
+	testing.expect(t, decoded == nil)
+}
+
+@(test)
+test_issue_7763__strict_2eq :: proc(t: ^testing.T) {
+	input := "=="
+	decoded, err := base64.decode(input, options = { .Strict })
+	testing.expect_value(t, err, .Invalid_Padding)
+	testing.expect(t, decoded == nil)
+}
+
+@(test)
+test_issue_7763__strict_3eq :: proc(t: ^testing.T) {
+	input := "==="
+	decoded, err := base64.decode(input, options = { .Strict })
+	testing.expect_value(t, err, .Invalid_Padding)
+	testing.expect(t, decoded == nil)
+}
+
+@(test)
+test_issue_7763__strict_4eq :: proc(t: ^testing.T) {
+	input := "===="
+	decoded, err := base64.decode(input, options = { .Strict })
+	testing.expect_value(t, err, .Invalid_Padding)
+	testing.expect(t, decoded == nil)
+}
+
+@(test)
+test_issue_7763__strict_Aeq :: proc(t: ^testing.T) {
+	input := "A="
+	decoded, err := base64.decode(input, options = { .Strict })
+	defer delete(decoded)
+	testing.expect_value(t, err, .Invalid_Padding)
+	testing.expect(t, decoded == nil)
+}
+
+@(test)
+test_issue_7763__strict_QQ :: proc(t: ^testing.T) {
+	input := "QQ"
+	decoded, err := base64.decode(input, options = { .Strict })
+	testing.expect_value(t, err, .Invalid_Padding)
+	testing.expect(t, decoded == nil)
+}
+
+@(test)
+test_issue_7763__strict_QQ1eq :: proc(t: ^testing.T) {
+	input := "QQ="
+	decoded, err := base64.decode(input, options = { .Strict })
+	testing.expect_value(t, err, .Invalid_Padding)
+	testing.expect(t, decoded == nil)
+	delete(decoded)
+}
+
+@(test)
+test_issue_7763__strict_QQ2eq :: proc(t: ^testing.T) {
+	input := "QQ=="
+	decoded, err := base64.decode(input, options = { .Strict })
+	testing.expect(t, err == nil)
+	testing.expect(t, slice.equal(decoded, { 'A' }))
+	delete(decoded)
+}
+
+@(test)
+test_issue_7763__strict_QQ3eq :: proc(t: ^testing.T) {
+	input := "QQ==="
+	decoded, err := base64.decode(input, options = { .Strict })
+	testing.expect_value(t, err, .Invalid_Padding)
+	testing.expect(t, decoded == nil)
+	delete(decoded)
+}
+
+@(test)
+test_issue_7763__strict_QQ4eq :: proc(t: ^testing.T) {
+	input := "QQ===="
+	decoded, err := base64.decode(input, options = { .Strict })
+	testing.expect_value(t, err, .Invalid_Padding)
+	testing.expect(t, decoded == nil)
+	delete(decoded)
+}
+
+@(test)
+test_issue_7763__strict_QQ6eq :: proc(t: ^testing.T) {
+	input := "QQ======"
+	decoded, err := base64.decode(input, options = { .Strict })
+	testing.expect_value(t, err, .Invalid_Padding)
+	testing.expect(t, decoded == nil)
+	delete(decoded)
+}