A native-first language built for game development.
The working language spans deterministic disposal and using, a mature object model, nested and readonly value types, jagged and rectangular arrays, completed closures and iterators, declaration/property/recursive patterns and switch expressions, structured exceptions and cleanup, inferred and constrained generics, extension methods, static/default interface methods, custom events, nullability, GC, native interoperability, source-only validation, native debug mapping, and a compiler-backed language server.
Language & runtime
The important part is composition: nullable values work through operators and storage, initializers build real graphs, static references stay rooted through GC, generic collections accept collection initializer syntax, and the same semantic model is reused by builds and tooling.
Current Classes, nested/readonly structs, inheritance, constructor chaining/delegation, interface inheritance, struct interface implementation/boxing, static interface property/event contracts, virtual/abstract/override properties, generic types/methods with class/struct/base/interface/new() constraints, explicit generic calls through arbitrary receivers, delegates, nested/by-reference closures, custom and field-like events, attributes, and runtime discovery.
Current Single-dimensional, jagged, and rectangular arrays with inferred rectangular initializer shapes; List<T>, Queue<T>, Stack<T>, Dictionary<TKey,TValue>, HashSet<T>; foreach, enumerators, and iterator state machines with ordinary inferred/definitely-assigned/shadowed locals.
Current Nested value structs, readonly struct, readonly instance methods/accessors, calls through in, value copying/defaults, generic/nullable/static value layouts, and recursive GC tracing through managed references inside nested structs.
Current Nested lambdas, per-iteration foreach capture frames, ref/out/in captures and lambda parameters, struct this capture, and iterator state across foreach, switch, nested loops, base-member access, and suspension.
Current Compound assignment through indexers and writable vector swizzles preserves single evaluation of receivers, indices, and right-hand sides.
Current Native non-boxed T? storage, HasValue/Value, nullable fields/properties/arrays/generics, nullable enums/structs, and GC tracing through nullable structures containing managed references.
Current Lifted arithmetic/comparisons, ??, ??=, value-returning ?., and null-conditional indexing with ?[].
Current Named argument reordering, optional/default parameters, params, default(T), and target-typed default across locals, returns, arguments, fields, properties, generics, enums, pointers, structs, and nullable values.
Current Instance field and auto-property initializers run before constructor bodies, while object initializers apply normal accessible field/property assignments after one construction.
Current Inline arrays and collection initializer syntax through ordinary Add(...) binding, including generic collections, conversions, nullable values, and managed references.
Current Static fields/properties, static readonly, static constructors, before-first-use run-once initialization, base-before-derived ordering, generic static state, and GC roots for managed static references.
Current Enums, switch, const/readonly, casts, is/as, null operators, optional parameters, typeof, runtime type metadata, and user-defined implicit/explicit conversions.
Current Post-test do/while loops, expression-bodied methods/constructors/operators/conversions/setters, and custom event add/remove accessors all lower through the same existing semantic and code-generation paths.
Current Managed Exception types, throw, typed and catch-all catch, cross-call propagation, GC-safe unwinding, finally, structured return/break/continue through cleanup, nested handlers, bare rethrow, iterator/delegate/event integration, native/library boundaries, and static-initializer recovery now compose through one runtime-control-flow model.
Current Null-conditional indexing works across single-dimensional, jagged, and rectangular arrays. Rectangular initializers support explicit compile-time dimensions as well as new[,]-style inferred dimensions while preserving shape validation, conversions, row-major evaluation, and GC safety.
Current Target-typed ?: expressions compose with interface/reference values, structs through interface targets, delegates, nullable values, user conversions, generics, and single-evaluation semantics.
Current Projects can emit native static archives, export public static VOID methods with stable C symbols, preserve static initialization/GC roots across repeated calls, and be consumed from VOID or plain C through the existing native ABI.
Current Instance methods can be called through constructor/method/property/indexer/array/conditional/temporary receivers with single evaluation and GC safety. Explicit generic calls work through static, instance, inherited, virtual, interface, specialized-generic, and temporary receiver paths.
Complete IDisposable, generated iterator disposal, non-array foreach cleanup, using (...), and using var share the same structured cleanup machinery used by finally, including early exits and exceptions.
Complete Generic method type inference, extension methods, static interface method contracts, constrained static calls through type parameters, and default interface methods reuse the existing overload, monomorphization, and interface-dispatch systems.
Complete Declaration/type, constant/null, relational, logical, property, and recursive patterns compose with flow-aware locals, deterministic pattern-switch ordering, when guards, and target-typed switch expressions.
Complete User-defined unary and binary operators use normal overload/conversion resolution, static interfaces can require operators, and constrained generic code dispatches those operators through monomorphized concrete implementations. Iterator lowering preserves generic constraint provenance across yield.
Current Garbage collection traces managed references across objects, inheritance, interfaces, nullable structures, collections, iterators, delegates, closures, events, and static roots.
Current Pointers, unsafe delegates with pointer and by-reference pointer signatures, pointer properties across unsafe classes/interfaces/value types, pointer constructors, native structs, native ref/out/in, callbacks, aliases, local native dependencies, reusable VOID static-library output with exported C symbols, sizeof, memory copy/clear, and stackalloc.
Compiler tooling
Source spans and ranged diagnostics feed both voidc check and voidc lsp. The semantic query layer powers hover, signature help, completion, go-to-definition, references, and document/workspace symbols. Live diagnostics analyze unsaved buffers, UTF-8 compiler positions are converted to LSP UTF-16 coordinates, and multi-file editor sessions are analyzed as one in-memory project snapshot so dependent files do not see stale disk state.