Home / Docs / Error Codes

GALA Compiler Error Codes

Every semantic error the GALA transpiler emits carries a stable error code of the form GALA-Exxxx. Codes are opaque identifiers — they never change meaning across releases, so tools, tests, CI checks, and documentation can link against them.

If the compiler handed you a code, find it in the table below and jump straight to the page for it.

Anatomy of a GALA error

gala build, gala run, and gala transpile print a framed diagnostic:

error[GALA-E0002]: non-exhaustive match: missing cases: Blue
  --> main.gala:10:5
   |
10 |     case Red()   => "red"
   |     ^^^^ add the missing variant cases, or add a `case _ => ...` defa…
   |
   = hint: add the missing variant cases, or add a `case _ => ...` default to cover them

Diagnostics raised before a source position is known — package resolution and the type-inference engine — print the header and hint with no frame.

Batch analysis and your editor show the same diagnostic in a terse single-line form, because the language server consumes that shape:

Error transpiling main.gala: [SemanticError GALA-E0002] main.gala:10:4 non-exhaustive match: missing cases: Blue (hint: add the missing variant cases, or add a `case _ => ...` default to cover them)

Same code, same message; the column is zero-based in the terse form. See Compiler DX for more on the diagnostic renderer.

All error codes

Every code the compiler can emit now has a page. Codes are never renumbered and never change meaning, so a code you find in an old build log still means the same thing here.

Codes you will not see in practice

Five codes exist in the compiler but no valid source reaches them. Each still has a page, because a stable code is worth documenting even when it is a backstop:

GALA-E0021 is a related case: the code exists, but everyday type mismatches transpile cleanly and surface from the Go compiler afterwards, pointing back at your .gala line. GALA’s inference deliberately leaves type checking to Go.

By category

Pattern matching and sealed types — E0002, E0003, E0004, E0005, E0006, E0015, E0018, E0031. Start with Pattern Matching and Sealed Types.

Collections and Go interop — E0007, E0008. See Collections and Go Interop.

Declarations — E0011, E0012, E0013, E0014, E0016, E0034.

Redeclaration — one name declared twice: E0011 types · E0012 methods · E0027 functions · E0028 type aliases · E0029 interface method specs · E0030 struct fields · E0031 sealed cases. GALA has no overloading, so a second declaration is always a mistake.

Type inference — E0018, E0021, E0022, E0023, E0033. See Type Inference.

Packages and imports — E0010, E0020, E0025, E0026, E0032. See Dependency Management.

Go constructs with no GALA surface — E0007 slice literals · E0008 map literals · E0035 builtins like len and panic · E0036 statement keywords like defer and go. Each names its GALA replacement.

Literals — E0038 invalid string escape · E0019 empty () used as a value.

Immutability and concurrency safety — E0001, E0037. See Immutability and Concurrency Safety.

Transpiler bugs — E0009, E0017, E0024. These mean the transpiler hit a case it does not handle; please file an issue with the source snippet.

Further Reading

• Documentation Hub — language reference, standard library, and guides
• Compiler DX — framed diagnostics, carets, and GALA source positions in stack traces
• Pattern Matching — exhaustive matching, destructuring, and guards
• Sealed Types — closed hierarchies with compile-time exhaustiveness
• Concurrency Safety — the shareability model behind GALA-E0037
• Error Handling — Option, Either, and Try for runtime failures (compile-time codes are on this page)