iwillspeak/feersum

Feersum is a Scheme compiler and runtime ecosystem built on .NET, designed to compile Scheme source code into .NET assemblies. It provides a multi-stage compilation pipeline with a hygienic macro system, a command-line interface, and an interactive REPL for development and execution. The system includes a language server for IDE integration, an MSBuild SDK for project management, and core libraries implementing standard Scheme procedures.

7 changes.

This period established the foundational structure of the Feersum Scheme compiler, including build infrastructure, CLI tools, and the Serehfa core library. It also introduced comprehensive test suites to verify the correctness of the compiler pipeline, parser, and macro expansion logic.

15 changes.

This period focused on establishing the Feersum SDK ecosystem, including MSBuild integration, project templates, and cross-project build support. The compiler underwent a major architectural overhaul, introducing a multi-stage pipeline, a new hygienic macro system, and structured diagnostics. Additionally, core Scheme libraries and a language server were implemented to provide foundational runtime capabilities and IDE integration.

A new example project has been added to demonstrate the Feersum SDK. It includes a \HelloWorld.scmproj\ project file configured to target both .NET 8.0 and .NET 10.0, and a \hello.scm\ source file that imports the Scheme write library to display a 'Hello World!' message.

examples/HelloWorld · high confidence

A new example project has been added to demonstrate the capability of assembling multiple source files into a single executable. The example includes a library file (lib.scm) that exports a 'greet' function and a main file (main.scm) that imports and uses it, compiled via a .NET SDK project targeting .NET Framework 4.8.1.

examples/MultiFile · high confidence

New .NET project templates have been added for creating Scheme-based applications and libraries. Users can now generate a Scheme class library (scm-classlib) or a Scheme console application (scm-console), both of which default to targeting .NET 8.0 but allow selection of other frameworks like .NET 5.0, .NET 4.7.2, or .NET Standard 2.1. Additionally, a simple Scheme library declaration template (scmlib) is available for creating .sld files.

src/Feersum.Templates/templates · high confidence

A new example project has been added to demonstrate cross-project references within the SDK. The project targets .NET Framework 4.8.1 and imports functionality from a sibling project (MultiFile), illustrating how to structure and build solutions that span multiple project files.

examples/MultiProject · high confidence

The Serehfa module introduces a comprehensive set of built-in procedures for the Scheme language, covering arithmetic, booleans, characters, strings, symbols, lists, vectors, bytevectors, and I/O. It provides core data structures like \ConsPair\ and \Ident\, along with argument validation helpers, and implements standard R7RS libraries such as \scheme/time\, \scheme/process-context\, and \scheme/write\. This adds foundational capabilities for numeric operations, data manipulation, and environment interaction to the runtime.

src/Serehfa · high confidence

Establishes the foundational project structure for the Feersum Scheme compiler, including the solution file, core source projects, and test suites. Introduces build infrastructure with Directory.Build.props for centralized package metadata and MinVer-based versioning, alongside .editorconfig and .gitattributes to enforce consistent code formatting and line-ending behavior across Windows and Unix environments. Adds essential documentation (README, CONTRIBUTING, DEVGUIDE) and utility scripts for running specs and formatting code.

(repo-wide) · high confidence

The new \src/Feersum.Core\ project adds the \(scheme base)\, \(scheme cxr)\, and \(feersum core lists)\ libraries, providing core Scheme functionality implemented in the language itself. Users gain access to list manipulation procedures such as \append\, \reverse\, \list-tail\, \list-ref\, \list-set!\, \list-copy\, and member search functions (\memq\, \memv\, \member\) alongside association list searches (\assoc\, \assq\, \assv\). The \(scheme cxr)\ library exposes standard accessor combinations (e.g., \caar\, \cddr\) for nested list traversal, while \(scheme base)\ re-exports these along with fundamental primitives like \apply\, \list-\>vector\, and various type predicates and comparison operators, establishing the foundational runtime capabilities for Feersum programs.

src/Feersum.Core · high confidence

Users can now connect their editors to the Feersum Language Server, which provides real-time compiler diagnostics (errors and warnings) and semantic syntax highlighting. The server manages workspace state via an agent, converts Feersum compiler diagnostics to LSP format, and implements the Semantic Tokens protocol to highlight keywords, variables, strings, and comments.

Feersum.LanguageServer, src/Feersum.LanguageServer · high confidence

Added the Feersum SDK project, an MSBuild SDK package that enables Scheme language support in .NET projects. The package targets .NET 10.0 and includes SDK scripts, MSBuild targets, and props files. It automatically generates a version properties file during the build process to ensure the correct compiler version is used.

src/Feersum.Sdk · high confidence

The Feersum project now includes a functional command-line interface and interactive REPL for the Scheme language. Users can compile Scheme source files into .NET assemblies using the \feersum-scheme\ executable, specifying build configurations, output types (Library, Executable, or Script), and references via command-line arguments. The tool also supports an interactive Read-Eval-Print Loop (REPL) for immediate code evaluation and a dedicated parser REPL for inspecting syntax trees. Additionally, a new \feersum-stage1\ binary provides a cut-down compiler interface, and the main CLI supports telemetry tracing via the \--trace\ flag to monitor compiler performance.

src/Feersum · high confidence

The library now introduces three new attributes in the \Serehfa.Attributes\ namespace to explicitly define how C\# symbols are exposed to the Lisp runtime. \LispExportAttribute\ marks individual methods with a specific external name, \LispLibraryAttribute\ identifies classes as Scheme libraries and accepts one or more library names, and \LispReExportAttribute\ facilitates re-exporting items from other libraries by specifying the source library type, the item name, and whether it is a method. These attributes provide the metadata required for the compiler to generate the correct export bindings.

src/Serehfa/Attributes · high confidence

The compiler has been restructured into distinct stages (bind, lower, emit) within the new \Feersum.CompilerServices.Compile\ module, replacing the previous monolithic approach. This change introduces a new environment model where parent environments are derived from linked environment types rather than being stored separately, and adds compiler instrumentation via the .NET Meter API to expose metrics like compilation count, error count, and phase duration for monitoring.

src/Feersum.CompilerServices/Compile · high confidence

The Feersum template pack is now available as a dedicated NuGet package targeting .NET 10.0, replacing previous framework targets. The packaging process has been updated to use MinVer for versioning instead of GitVersion, and the build process now automatically injects the current package version into template project files (replacing the 'TEMPLATE\_VERSION' placeholder) to ensure generated projects reference the correct SDK version.

src/Feersum.Templates · high confidence

The binding layer has been rewritten to use a new Expression-based interface, replacing the legacy AST and SyntaxShim. This change introduces a new bound tree structure (BoundExpr, BoundBody) that resolves identifiers to storage locations (Locals, Globals, Captures) and supports proper environment capture for lambdas. It also implements a new hygienic macro expansion system using syntax-rules with hygiene-annotated syntax objects (Stx) and explicit binding identities (Ident) to prevent variable capture, along with new diagnostics for pattern and macro errors.

src/Feersum.CompilerServices/Binding · high confidence

The compiler now reports errors and warnings using a structured diagnostic system that includes specific error codes, titles, and precise source locations (line, column, and span). Diagnostics are formatted to conform to MSBuild canonical error standards, enabling better integration with IDEs and build tools. This change also introduces a source registry to track document offsets and resolve them to human-readable line/column positions, replacing previous ad-hoc error reporting.

src/Feersum.CompilerServices · high confidence

The compiler now uses a new syntax layer built on the Firethorn green/red tree model, replacing the previous implementation. This change introduces a functional lexer (Lex.fs) that tokenizes source code into specific kinds like numbers, strings, and peculiar identifiers, and a parser (Parse.fs) that constructs an Abstract Syntax Tree (Tree.fs) with proper diagnostic reporting for errors. Syntax construction is handled via a new factory module (Factories.fs) that creates nodes for constants, forms, quotations, and programs. Users benefit from improved error diagnostics and support for new syntax features such as peculiar identifiers and vector prefixes.

src/Feersum.CompilerServices/Syntax · high confidence

Add comprehensive test coverage for compiler components; Added specification tests for core Scheme features; Added test coverage for parser and macro expansion failures; Added test spec for infinite tail recursion; Added test suite for the Lower pass.

The Feersum compiler toolchain, including the main compiler, language server, and core types library, has been upgraded to target .NET 10.0. To support this migration and improve maintainability, the project now uses central package version management via Directory.Packages.props, explicitly defining versions for key dependencies such as Argu, ReadLine.Reboot, Firethorn, Mono.Cecil, and the xUnit v3 testing framework.

(dependencies) · high confidence

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

• CAI 64 → 64 (+0.2)
• Rubric changed (rubric-2026.09.15 → rubric-2026.10.1) — scores are not directly comparable.

• Code Health 97 → 96 (-1.0)
• Architecture 94 → 97 (+3.2)
• Maturity 72 → 72 (+0.0)
• Readiness 53 → 53 (+0.0)
• Security 63 → 63 (+0.0)

• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• No context/problem and no consequences/trade-offs; the only content is a rationale for red/green trees plus a citation (docs/design-docs/01-syntax-trees.md)
• redundant comment (src/Serehfa/Characters.cs)
• redundant comment (src/Serehfa/Ident.cs)

• FileTooLong: Binding/Binder.fs (src/Feersum.CompilerServices/Binding/Binder.fs)
• FileTooLong: Compile/Emit.fs (src/Feersum.CompilerServices/Compile/Emit.fs)
• Inconsistent naming convention for arithmetic operations. Most methods use a prefix 'Arith' followed by an abbreviated operator name (e.g., Arithadd, Arithsub, Arithgt), but 'Aritheq' uses a different abbreviation style ('eq' instead of 'eq' or 'equal') and 'ArithZero' breaks the verb/operator pattern entirely by naming the method after a value/constant rather than an operation.
• Inconsistent naming for equality comparison concepts. The codebase mixes 'Equal', 'Equals', 'Eq', and 'Equiv' for similar comparison operations across different namespaces (Characters, Symbols, Ident, Equivalence, Booleans, Strings). 'CharEqualCI' and 'CharEqual' use 'Equal', while 'SymbolEquals' and 'StringEquals' use 'Equals'. 'BooleanEq' and 'Eq' use 'Eq'. 'Equiv' is used in Equivalence. This creates confusion about whether these are distinct concepts or just inconsistent naming for the same idea.
• Inconsistent naming for factory/creation methods. Some types use 'New' (NewBytevector, VectorNew, ListNew) while others use 'Make' (MakeBytevector, MakeVector, MakeList). This inconsistency exists both within the same namespace (ByteVectors) and across namespaces.
• Inconsistent suffix usage for case-insensitive or case-conversion operations. 'Upcase', 'Downcase', and 'Foldcase' use full words, while comparison methods use the abbreviation 'Ci' (e.g., CharLtCi). This mixes full words and abbreviations for similar case-related concepts.
• No context/problem and no consequences/trade-offs; the only content is a rationale for Red/Green trees plus a citation (docs/design-docs/01-syntax-trees.md)

• Unchanged — 0 containers · 1 contexts · 0 edges

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

iwillspeak/feersum 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.