VOID Language
An independently designed game-development language with its own compiler, runtime, GC, standard library, native C output, and a compiler-side language server powered by the same semantic model as normal builds.
The language today
VOID now combines a broad object model, deterministic disposal and using, nested and readonly value types, jagged and rectangular arrays, completed closures and iterators, declaration/recursive patterns and switch expressions, user-defined and constrained generic operators, inferred and constrained generics, extension methods, static/default interface methods, structured exceptions with GC-safe unwinding and finally, nullable values, managed GC, reusable native library output, native/unsafe interoperability, precise diagnostics, source-only checking, semantic queries, and native debug information mapped back to original .void files.
Classes, nested/readonly structs, inheritance, interface contracts, constructor chaining/delegation, virtual properties, constrained generics, delegates, nested/by-reference closures, iterators, jagged/rectangular arrays, custom events, conditional and switch expressions, declaration/property/recursive patterns, user-defined operators and static-interface operator contracts, nullable values, and structured try/catch/finally exception flow all work together.
VOID lowers to portable C, then uses the system native compiler and linker. Debug builds preserve original VOID filenames and source lines through standard native debug information.
voidc check, live ranged diagnostics, hover, signature help, semantic completion, definitions, references, document/workspace symbols, and debug mapping all reuse the same compiler semantics used by real builds.
Current direction
Iterator pattern locals now survive suspension with correct lifetime/GC behavior, user-defined unary and binary operators share normal semantic resolution, and static-interface operator contracts enable constrained generic operator dispatch. The active phase now consolidates VOID conversion semantics around one authoritative semantic engine.
See the complete language/runtime surface, nullability, initialization, metadata, GC, unsafe code, and native integration.
02Object ModelConstructor chaining, interface inheritance, struct interfaces, virtual properties, events, delegates, and conditional expressions.
03Value Types & Control FlowNested/readonly structs, jagged and rectangular arrays, closure capture, iterator completion, compound targets, and GC-aware value layouts.
04ExceptionsThrow, handlers, propagation, GC-safe unwinding, finally, rethrow, iterator/delegate integration, and native boundary behavior.
05Lifetime & AbstractionsDeterministic disposal, using, generic inference, extension methods, static interface contracts, constrained calls, and default interface methods.
06Patterns & Switch ExpressionsDeclaration, relational, logical, property and recursive patterns, guarded switch cases, and expression-form switch.
07Operators & Generic MathUser-defined unary/binary operators, static-interface operator contracts, constrained generic dispatch, and iterator-safe generic provenance.
08Getting StartedSee the current project flow, source-only checking, native builds, and debug workflow.
09LibrariesStandard-library collections plus reusable VOID library projects, exported native entry points, archive output, and normal consumer linking.
10CompilerFrom parsing and semantics through C lowering, native binaries, checking, and debug mapping.
11DiagnosticsPrecise end-exclusive ranges shared across lexer, parser, semantic analysis, and checking.
12Toolingvoidc check, live diagnostics, hover/signatures, completion, navigation, references, symbols, source mapping, and multi-file editor state.
Pointers, ABI-safe structs, by-reference callbacks, memory primitives, stack allocation, local native dependencies, and library exports.
14ExamplesBrowse the working language, initialization, native, diagnostics, and tooling examples.
Built with a purpose
The same parser, semantic model, diagnostics, and symbols now power builds, source-only checks, live diagnostics, hover, completion, navigation, references, and workspace symbols. Editor clients can stay thin instead of duplicating language logic.
Nullable values, named arguments, target-typed defaults, initializers, static state, and deterministic type initialization compose normally.
voidc check runs the real front end without generating C, invoking a native compiler, or creating build outputs.
Tools can ask the compiler for symbols, types, definitions, members, and callable parameter metadata from one analyzed session.
Tokens, syntax, and compiler errors retain end-exclusive start/end source ranges.
Generated C emits standard line mappings so native debug information points back to original VOID files and lines.
Live diagnostics, hover, signatures, semantic completion, definitions, references, document/workspace symbols, and synchronized unsaved project state.
VOID lowers to C and links project-local native dependencies through its explicit unsafe ABI boundary.