TIHan/Oly

Oly is a compiler infrastructure that translates a custom programming language into .NET assemblies and GPU shaders via SPIR-V. It provides a full compilation pipeline including parsing, semantic analysis with scoped type safety, and intermediate representation optimization for both JIT and Ahead-of-Time deployment. The system includes a command-line interface and a VS Code extension for project management, syntax highlighting, and debugging support.

42 changes.

The project underwent a comprehensive restructuring of its compiler architecture, introducing scoped types, trait constraints, and a modular binder to enhance type safety and language features. Simultaneously, the codebase was migrated to .NET 10, with the .NET target adopting MSBuild for AOT and NativeAOT support, while legacy examples and the VS Code client were removed to streamline the ecosystem.

4 changes.

This period established the foundational Oly compiler infrastructure, introducing core components such as the .NET and SPIR-V emitters, a file watcher system, and a comprehensive CLI tool. The work included significant refactoring of the core library to add utilities for assertions, I/O, threading, and caching, alongside a suite of algorithm examples and GPU test helpers to validate the new capabilities.

The DotNet target now includes a dedicated numerics prelude (numerics\_dotnet.oly) that exposes Vector2, Vector3, Vector4, and Quaternion types along with standard math operations like round, floor, mix, and normalize, making these available to .NET projects. Additionally, the UnityTarget implementation has been removed from the codebase.

src/Runtime/Targets · high confidence

The Oly.Core library has been reorganized under the src/Core directory, introducing several new capabilities and behavioral updates. A new assertion module (Assert.fs) provides debug-only equality, containment, and null checks via the OlyAssert type. File and directory operations (IO.fs) now automatically skip files and directories prefixed with '\_\_oly'. JSON serialization (Json.fs) is standardized to use case-insensitive property names and indented output. Asynchronous execution (Threading.fs) now includes a StackGuard that ensures sufficient execution stack depth, spawning tasks when recursion limits are exceeded. Cancellation handling (Async.fs) introduces a thread-safe AsyncCancellationTokenSource with semaphore-based synchronization. Path handling (Path.fs) is now a struct with case-insensitive equality and new methods for relative paths and component checking. Immutable array operations (ImArray.fs) have expanded with new functions for mapping, picking, and filtering across multiple arrays. External process management (ExternalProcess.fs) now supports sending input lines and automatically restarting the process if it fails to respond. Finally, caching (CacheValue.fs) adds a thread-safe Least-Recently-Used (LRU) cache and a thread-safe lazy value type.

src/Core · high confidence

The Oly VS Code extension is introduced, providing a Solution Explorer view to browse projects and files, a Syntax Tree view to inspect the AST of Oly documents, and a command to automatically generate a launch configuration for .NET Core debugging. The extension integrates with the Oly language server to handle builds, project management, and diagnostics, and includes a basic test suite to verify extension registration.

vscode/src · high confidence

This change introduces the core components of the Oly compiler, including a new file watcher system for monitoring directory changes, a DotNet metadata builder and emitter for generating .NET assemblies, and a SPIR-V emitter for GPU code generation. It also adds a suite of Data Structures and Algorithms examples (Binary Search Tree, Bubble Sort, Insertion Sort, Quick Sort) along with their corresponding test suite to demonstrate the language's capabilities.

(repo-wide) · high confidence

The Oly CLI tool is now available in src/CLI, providing users with commands to build projects (with configurable verbosity and configuration), clean build artifacts, and install the compiler. The CLI is built on .NET 10.0 and uses Spectre.Console.Cli for command-line parsing, exposing a structured interface for project management tasks previously handled by the bootstrap script.

src/CLI · high confidence

The Oly.Runtime module introduces two new compiler optimizations—Assertion Propagation and Common Subexpression Elimination—to improve generated code efficiency. The underlying Intermediate Representation (IR) is significantly expanded to support new language features: type parameters now accept constraints (such as Struct, Unmanaged, Blittable, and Trait types), and the GenericContext type now tracks passed witnesses to handle generic instantiation correctly. Additionally, the IR adds operations for constrained calls, fixed-size arrays, and default initialization of type variables, while function signatures are updated to include witness and type argument keys for more precise overload resolution.

Oly.Runtime · high confidence

The Skyrogue example project and its associated configuration files (Skyrogue.json, Skyrogue.olyx) have been removed. This change eliminates the example's reliance on the AssetManager module and its specific Unity/Steam path references, effectively cleaning up the examples directory by removing this deprecated or incomplete demo.

vscode/examples/Skyrogue · high confidence

The VS Code client extension implementation, including the main extension entry point (\extension.ts\) and its TypeScript configuration (\tsconfig.json\), has been removed from the repository. This deletion eliminates the client-side code responsible for language server communication, syntax tree visualization, and semantic token handling within the VS Code environment.

vscode/client · high confidence

The internal Assert module and the FileWatcher component have been removed from the core library. This eliminates the custom assertion helpers (such as OlyAssert.Equal and Contains) and the DirectoryWatcher type that monitored file system events, indicating a shift away from these specific internal implementation details in the current codebase.

src/Oly.Core · high confidence

The \OlyWorkspace.fs\ and \OlyWorkspace.fsi\ files, which defined the core workspace abstraction including project management, document handling, and build infrastructure for the \Oly.Compiler.Service\, have been removed. Additionally, the \prelude.oly\ standard library example and the \examples.code-workspace\ configuration file have been deleted, indicating a cleanup of legacy or unused compiler service components and associated examples.

src/Compiler/Oly.Compiler.Service, vscode/examples, vscode/examples/core · high confidence

The AssetManager example, including its configuration, source code, and dependencies, has been removed from the distribution.

vscode/examples/AssetManager · high confidence

The example project files for the LLVM runtime target, specifically the configuration file (Oly.Runtime.Target.LLVM.json) and the source definition file (Oly.Runtime.Target.LLVM.olyx), have been deleted from the repository. This removes the local debugging configuration and the example code that previously demonstrated LLVM module creation and F\# interop using LLVMSharp.

vscode/examples/HelloWorld, vscode/examples/Oly.Runtime.Target.LLVM · high confidence

The \Win32Example.json\ configuration file and the \Win32Example.olyx\ source file have been deleted from the \vscode/examples/Win32Example\ directory. This removes the previous Win32 windowing implementation, which targeted .NET 6 and utilized the Oly language syntax for creating a basic window and message loop, from the example set.

vscode/examples/Win32Example · high confidence

The public symbol API has been refactored: the \OlySymbol\ base type no longer requires a syntax node in its constructor, and \TryGetDefinitionLocation\ now accepts an \OlyBoundModel\ parameter. New capabilities include \ISymbolCollector\ for symbol gathering, relaxed cross-assembly equality checks for entities and types, and additional type-checking members on \OlySymbol\ (such as \IsType\, \IsFunction\, \IsConstructor\, \IsProperty\, \IsField\, and \IsFieldOrAutoProperty\). The previous \PublicAnalysis.fs\ file, which exposed \OlyAnalysisExpression\ and analyzer execution logic, has been removed.

src/Compiler/Oly.Compiler/PublicAPI · high confidence

The project solution has been restructured: several components have been renamed (e.g., Oly.Runtime.Clr to Oly.Emitters.DotNet, Oly.Runtime.Target.DotNet to Oly.Targets.DotNet) and moved to new directory paths (e.g., src\\Runtime\\Targets\\DotNet to src\\Emitters\\DotNet). Additionally, a new 'Checked' build configuration has been introduced alongside Debug and Release, enabling builds with additional runtime checks for CIL instructions. New projects for SPIR-V targets and CLI tools (olylib, oly\_bootstrap) have also been added to the solution.

(repo-wide) · high confidence

The benchmark suite in src/Benchmarks has been refactored to measure DotNet compilation performance rather than syntax parsing. The previous LargeSyntaxExample benchmark file was removed, and Program.fs now instantiates a DotNetCompile benchmark type. This change includes adding references to Oly.Compiler, Oly.Runtime, and Oly.Targets.DotNet, although the current benchmark implementation is a placeholder that does not yet perform actual compilation work.

src/Benchmarks · high confidence

The compiler's binder has been restructured into distinct phases (Pass0 through Pass4) and a new PrePass, moving logic from monolithic files into specialized modules like Attributes.fs and EarlyAttributes.fs. This change introduces early binding for built-in attributes (such as import, export, and intrinsic) and refactors how attribute arguments and named arguments are validated and bound. Additionally, the binding pipeline now automatically opens the enclosing namespace of modules during the binding passes, and the public API for the binder has been updated to reflect the new pass structure and environment creation.

src/Compiler/Oly.Compiler/Binder · high confidence

The compiler's binding and analysis layers have been significantly restructured to support new language features and improve internal consistency. A new \BinderConfiguration\ allows controlling default accessor visibility (public vs. private), and the \BinderEnvironment\ now tracks detailed context flags (such as being in a type argument or export) and includes the current assembly. Post-inference analysis has been expanded to enforce scope limits for 'scoped' types, preventing illegal boxing or address escapes, and introduces an 'unmanaged allocation only' constraint. The bound tree has been updated to support 'scoped' lambda flags, new inline control flags (inline always/never), and simplified syntax info structures. Additionally, the IL generator and importer have been refactored to use \EntitySymbol\ directly instead of the generic \IEntitySymbol\, and to handle new function instance signatures and debug source text ranges more robustly.

Oly.Compiler · high confidence

The compiler now supports try/catch/finally blocks, scoped function types, and a new mutable array syntax. Implicit conversions for enum types are enabled via new rules, and the 'upcast' intrinsic has been replaced by 'unsafe\_cast'. The 'scoped' constraint is introduced for type parameters, and partial application (partial calls) is now supported. Several bugs related to overloading, generics, and byref types have been fixed.

src/Compiler/Oly.Compiler · high confidence

The compiler's symbol handling has been significantly restructured to improve type safety and constraint resolution. The \IEntitySymbol\ interface has been replaced by the concrete \EntitySymbol\ class, and the \EntitySymbolBuilder\ now utilizes \ResizeArray\ for nested entities and enforces stricter pass-based initialization for fields and runtime types. New capabilities include \IFunctionSymbol.IsOverriding\ and \IPropertySymbol.IsOverriding\ for accurate override detection, and a comprehensive \Validate\ function for well-known intrinsic functions (replacing the previous \upcast\ intrinsic with \unsafe\_cast\). Additionally, the type system now supports \TypeVariableRigidity\ levels (including \MostFlexible\) for better higher-kinded inference, and the \SymbolQuery\ module introduces granular flags for querying member overrides and combining concrete with extension members.

src/Compiler/Oly.Compiler/Symbols · high confidence

The OlyWorkspace interface now returns diagnostics alongside the build result in BuildProjectAsync, allowing users to inspect compilation errors and warnings directly from the build operation. Additionally, the workspace introduces explicit support for transitive project references via OlyProjectReference and OlyImportedReference, enabling users to control whether references are propagated transitively. The API also exposes methods for resolving references (ResolveReferencesAsync) and importing them (ImportReferenceAsync), providing finer control over dependency resolution and file copying during the build process.

Oly.Compiler.Workspace · high confidence

The HelloWorld example now targets .NET 10.0 and includes new variants for Ahead-of-Time (AOT) and Ready-to-Run (R2R) publishing, allowing users to build and run the example with these specific deployment modes. Additionally, the JIT example located in the same directory has been moved to the root examples folder, updated to target .NET 10.0, and refactored to use the new \Unsafe.UnmanagedCast\ API instead of the previous \UnsafeCast\ method.

examples/HelloWorld · high confidence

The .NET target now uses MSBuild to compile generated code, replacing previous build mechanisms. This change introduces support for various publish modes including JIT, Standalone, ReadyToRun, and NativeAOT, allowing users to choose their preferred deployment strategy. The system automatically generates temporary project stubs in a dedicated directory to prevent IDE interference, handles dependency resolution for file references, project references, and NuGet packages, and manages the build output cleanup process.

Oly.Targets.DotNet · high confidence

The language server entry point has been replaced with a minimal stub that initializes the OmniSharp Language Server protocol infrastructure but currently registers no specific handlers or services. This change removes the previous extensive implementation in Program.fs, which included syntax tree view models, diagnostic creation, hover text generation, and custom compile requests, effectively stripping the server of its current language features and diagnostic capabilities.

src/LanguageServer · high confidence

The compiler's syntax layer now supports the 'field' keyword and introduces stricter validation for character literals, flagging newlines within them as errors. Conditional preprocessor directives have been restructured to support more complex token sequences, and the lexer's string interning has been moved from global state to instance-level storage to improve thread safety and reduce memory footprint. Additionally, the parser's backtracking buffer and token peeking mechanisms have been optimized for performance, and the 'mutable' keyword is now correctly recognized on parameter patterns.

src/Compiler/Oly.Compiler.Syntax/Internal · high confidence

The VS Code extension has migrated its linting setup from legacy \.eslintrc\ files to the new flat \eslint.config.js\ format, removing the old configuration files and \.eslintignore\. Additionally, the \tsconfig.json\ has been updated to remove project references to client and server modules, restrict TypeScript types to Node.js, and adjust the target library configuration.

vscode · high confidence

The compiler's bound tree API has been refactored to remove the 'syntaxNameOpt' parameter from expression constructors (such as Call, SetValue, and GetProperty) and replace 'IsLocal' checks with 'HasLocalEnclosing' to better distinguish local variables from other scopes. In pattern matching, the 'TargetJump' mechanism is replaced by 'InlineAlways' and 'StaticLocal' flags on continuation functions, eliminating closure allocations for jump targets. Additionally, auto-property lowering now uses 'CreateGeneratedSequential' and 'CreateGeneratedValue' to mark generated code, and the optimizer enforces stricter rules for local variable elimination.

src/Compiler/Oly.Compiler/Lowering · high confidence

The syntax tree implementation has been refactored to remove several internal node wrapper types (OlySyntaxSeparatorList, OlySyntaxList, OlySyntaxBrackets, OlySyntaxBracketInnerPipes, and OlySyntaxCurlyBrackets) from the generated code, simplifying the node hierarchy. Token handling has been expanded to support new directive types (DirectiveFlag, ConditionalDirective, PropertyDirective) with dedicated accessors (TryConditionalDirectiveText, TryPropertyDirectiveText) and a new GetSubTokens method that breaks down complex tokens into their constituent parts. Additionally, the text model now uses a new OlyTextLine and OlyTextLineCollection structure with optimized line-position lookup using binary search and caching, and the OlySyntaxAccessor now supports a CHECKED configuration for additional validation.

src/Compiler/Oly.Compiler.Syntax · high confidence

The OlyIL metadata definitions have been updated to support new language features and improve internal consistency. The \OlyILEntityKind\ enum removes the \Attribute\ variant, reflecting the decision to treat attributes as standard structs or classes. New flags have been added to \OlyILEntityFlags\ (including \Scoped\, \AttributeImporter\, and \Anonymous\) and \OlyILFunctionFlags\ (such as \InlineAlways\, \InlineNever\, and \UnmanagedAllocationOnly\), while \OlyILMemberFlags\ has been removed in favor of the unified entity flags. Additionally, the file introduces helper modules for special names (\OlySpecialNames\), quoted name handling (\OlyQuotedName\), and fully qualified type name parsing, and adds a \GetNil\ static member to \OlyILTableIndex\ for better nil handling.

Oly.Metadata · high confidence

The runtime now includes a new optimization pipeline featuring local normalization, copy propagation, dead code elimination, and function inlining to improve performance. It also introduces tiered compilation (Tier0, Tier1, Tier2) to allow for faster initial execution with minimal optimizations. Additionally, the emitter interface has been updated to support new type definitions, properties, and fixed arrays.

src/Runtime/Oly.Runtime · high confidence

The compiler's diagnostic system now produces structured error and warning messages that include the source file path, line/column location, a standardized code prefix (defaulting to 'OLY'), and a four-digit error code. This change also adds support for cancellation tokens in diagnostic generation and helper text retrieval, allowing for more responsive tooling interactions. Additionally, the formatting logic has been improved to handle multi-line spans and zero-width spans more robustly, ensuring that diagnostic output is consistent and machine-parseable.

Oly.Compiler.Syntax · high confidence

The syntax generator now assigns unique tags to internal syntax nodes and uses these tags for dispatch in the conversion logic, replacing the previous pattern-matching approach based on runtime type checks (e.g., \:? SyntaxToken\). This change also switches child node casting to use \System.Runtime.CompilerServices.Unsafe.As\ instead of F\#'s \:?\>\ operator, and updates the \FullWidth\ calculation to use \TryGetFirstNonTriviaToken\ instead of \TryGetFirstToken\. Additionally, a new \CHECKED\ build configuration is introduced alongside \DEBUG\ to enable specific validation logic.

Oly.Compiler.SyntaxGenerator · high confidence

The workspace logic has been reorganized into a new Oly.Compiler.Workspace assembly, introducing OlySourceTextManager for immutable source text tracking and OlyWorkspaceListener for file system events. Semantic classification has been updated to use literal-based kinds (e.g., NumberLiteral, BoolLiteral) instead of constant-based ones, and now supports pattern matching classification (Pattern, AbstractPattern) and conditional directives. Completion items now include an insert range, and the workspace exposes new methods for retrieving documents and solutions.

src/Compiler/Oly.Compiler.Workspace · high confidence

Added GPU test helper utilities for SPIR-V validation; Added conformance tests for byref scoping and scoped lambda capture rules; Added conformance tests for compiler crash safety and access control; Added conformance tests for types, syntax, and constraints; Added conformance tests for unmanaged allocation-only analysis; Added tests for ambiguity resolution and syntax updates; Added tests for runtime optimizations and updated test infrastructure; Compiler test suite updates and refactoring; Enhanced test utilities for configurable compilation and stress testing; Expanded compiler conformance tests for expressions, patterns, and error handling; Updated constraint conformance tests and syntax expectations; Updated test infrastructure and added tests for workspace and completion features.

The project has been upgraded to target .NET 10.0 across all components, including the CLI, compiler, runtime targets, and language server. This migration is accompanied by a significant update to the test infrastructure, upgrading xUnit to 2.9.3, the test SDK to 18.0.1, and coverlet to 6.0.4, while also introducing a 'Checked' build configuration for debugging and performance analysis. Additionally, the VS Code extension client has been migrated from npm to pnpm, and the Mono.Cecil dependency for the .NET emitter has been removed in favor of a new metadata module.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 58 → 60 (+2.0)
• Rubric changed (rubric-2026.09.15 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 51 → 51 (+0.0)
• Architecture 94 → 80 (-13.2)
• Maturity 49 → 55 (+5.9)
• Readiness 69 → 70 (+0.8)
• Security 92 → 92 (+0.0)
• Performance 94 (new)

• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview (README.md)
• High CVE: [GHSA redacted] (vscode/package-lock.json)
• High CVE: [GHSA redacted] (vscode/package-lock.json)

• CompilerImports.importEntityFlags (cognitive 17) (src/Compiler/Oly.Compiler/CompilerImports.fs)
• Helpers.decodeTypedArg (cognitive 17) (src/Runtime/Targets/DotNet/Oly.Compiler.CIL.Importer/Importer.fs)
• Helpers.decodeTypedArg (cyclomatic 31) (src/Runtime/Targets/DotNet/Oly.Compiler.CIL.Importer/Importer.fs)
• High CVE: [GHSA redacted] (vscode/package-lock.json)
• High CVE: [GHSA redacted] (vscode/package-lock.json)
• Hotspot: src/Compiler/Oly.Compiler/PublicAPI/PublicSymbols.fs (src/Compiler/Oly.Compiler/PublicAPI/PublicSymbols.fs)
• OlyAttributeTypeProvider.System.Reflection.Metadata.ICustomAttributeTypeProvider<Oly.Metadata.OlyILType>.IsSystemType (cognitive 20) (src/Runtime/Targets/DotNet/Oly.Compiler.CIL.Importer/Importer.fs)

• 15 commits — 15 feature/other, 0 fixes

• src/Runtime — 10 commits
• src/Compiler — 5 commits

• change: Decoding is hard
• change: Do not emit attributes for external stuff
• change: Handle errors
• change: Importing DotNet attribute arguments
• change: Importing all other attributes
• change: Importing everything
• change: Importing more attributes and fixing a few issues
• change: Initial work for attribute importing
• change: Refactoring IsParameter
• change: cleanup
• change: work
• change: work
• change: work
• change: work
• change: works, but with no values imported

• Unchanged — 0 containers · 17 contexts · 32 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

TIHan/Oly was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.