hamler-lang/hamler

Hamler is a programming language compiler that translates source code into Erlang, enabling execution on the Erlang virtual machine. It provides a comprehensive standard library that exposes Erlang/OTP capabilities—such as process management, distributed systems, database access, and network I/O—through a functional interface. The system includes a build toolchain, an interactive REPL, and a property-based testing framework to support development and verification.

The library now provides new modules for managing application configuration, resources, and lifecycle callbacks. The \Config\ module exposes functions to retrieve configuration values of various types (e.g., \getAtom\, \getBool\, \getInt\) from the application environment. The \Resource\ module allows fetching the application specification (\getAppSpec\). The \Callback\ module implements the FFI interface for application start, pre-stop, and stop hooks, enabling users to integrate with the application lifecycle.

lib/Control/Application · high confidence

The library introduces new modules for application management, monadic effects, and process control, alongside parsing and JSON support. Control.Application provides FFI bindings for Erlang's application module, exposing functions to start, stop, and manage application lifecycles. Control.Monad implements the Monad, Applicative, and Functor typeclasses with FFI bindings for list and IO operations. Control.Process offers FFI bindings for Erlang's process management, including message passing, linking, monitoring, and process control. Additionally, Text.Json provides a JSON parser, and Text.Parsec introduces a parser combinator library for text parsing.

lib/Control · high confidence

Users can now call external functions from other modules using the new Foreign module, which provides FFI wrappers (ffi0-ffi7 and their IO variants) to invoke functions with up to seven arguments, as well as an unsafeCoerce function for direct type casting.

lib · high confidence

The lib/Foreign directory is introduced, providing functional programming utilities in Erlang. This includes a Curry module for partial application and a Maybe module offering a Maybe type with ?Just and ?Nothing macros, alongside their respective header files.

lib/Foreign · high confidence

Introduces new FFI modules and type definitions for OTP behaviours: GenEvent, GenServer, GenStatem, and Supervisor. Each behaviour includes a main module (e.g., \Control.Behaviour.GenEvent\), a proxy module (e.g., \Control.Behaviour.GenEvent.Proxy\), and associated types (e.g., \Control.Behaviour.GenEvent.Types\). These modules provide APIs for starting, stopping, and interacting with these OTP processes, including callbacks for initialization, event handling, and state transitions.

lib/Control/Behaviour · high confidence

The library introduces a new Identity data type that implements Functor, Applicative, Monad, Foldable, Traversable, and various typeclass instances (Eq, Ord, Show, etc.), providing a simple wrapper for single-value contexts. Additionally, Max and Min newtypes are added to support ordered data structures, implementing Semigroup and Monoid instances that track maximum and minimum values respectively.

lib/Data/Functor · high confidence

A new module, Data.Term.Persistent, has been introduced to provide an interface for managing persistent terms in memory. This module exposes functions to store, retrieve, and erase named terms, as well as query information about the memory usage and count of persistent terms. This allows users to persist data across function calls or sessions using a key-value store mechanism.

lib/Data/Term · high confidence

Added the QuickCheck library to the codebase, providing a new testing framework for property-based testing. The implementation includes a random number generator module (QuickCheck.erl) and a core module (QuickCheck.hm) that defines types and classes for generating random values (Arbitrary), creating random generators (Gen), and running property checks. This enables users to write and execute automated tests using the QuickCheck methodology.

lib/Test · high confidence

Users can now build and install Hamler via RPM packages. This change introduces a new Makefile and spec file in the deploy/packages/rpm directory, enabling the creation of .rpm files for Linux distributions that support RPM-based package management.

deploy/packages/rpm · high confidence

The library introduces three new monad transformer modules: Reader, State, and Writer. The Reader module provides a read-only environment context with \ask\ and \local\ accessors. The State module adds mutable state management with \get\, \put\, \modify\, and \evalState\/\execState\ helpers. The Writer module supports logging or accumulating values via a Monoid, offering \tell\, \listen\, and \pass\ operations. Each module implements Functor, Applicative, and Monad type classes, enabling composable effect handling for their respective use cases.

lib/Control/Monad · high confidence

Users can now access new experimental modules in the System namespace, including System.Code for module loading and path management, System.Dir and System.File for directory and file operations (create, delete, copy, read, write), System.Env for environment variables, System.Error for exception handling, System.Init for boot and restart control, System.Logger for logging, System.OS for process and system information, System.Random for random number generation, System.Timer for timer management, and System.VM for VM statistics and configuration. These modules provide FFI bindings to Erlang/OTP functions, enabling file system manipulation, environment variable access, and system monitoring.

lib/System · high confidence

The System.IO module is expanded with new files: System.IO.Printf, which provides a printf-style formatting function supporting format specifiers for integers, floats, and strings, and System.IO.Types, which defines the IO monad wrapper, file path type, and I/O mode/seek mode enums. This introduces new formatting capabilities and type definitions for IO operations.

lib/System/IO · high confidence

Introduces new modules for distributed Erlang/OTP functionality, including Global, GlobalGroup, NetAdm, NetKernel, Node, PG, Port, RPC, and Slave, each with corresponding FFI bindings for the host language.

lib/Control/Distributed · high confidence

The lib/Database area now includes new experimental database modules for Erlang's ETS, DETS, and Mnesia systems. These modules provide foreign function interface (FFI) wrappers for common database operations such as creating tables, inserting and deleting records, querying data, and managing table metadata. The ETS module exposes functions for in-memory table management, the DETS module handles disk-based storage, and the Mnesia module provides distributed database capabilities. All three modules are marked as experimental and include comprehensive function exports for database interactions.

lib/Database · high confidence

The lib/Data directory now includes a comprehensive set of new modules for common data structures and utilities. This includes Array, Atom, Atomics, Binary (with Base64 support), Bits, Bool, Char, Counters, DateTime, Digraph, EVal, Either, Enum, Eq, Float, Foldable, Function, and Functor. These additions provide users with native support for arrays, directed graphs, atomic counters, bit manipulation, and functional programming constructs like Functors and Foldables.

lib/Data · high confidence

New files have been added to the repository to enable building .deb packages for the Hamler language. This includes a Makefile to orchestrate the build process, a debian/rules script to handle the packaging steps, a debian/control file defining package metadata and dependencies, a debian/changelog, and a debian/copyright file containing the Apache 2.0 license text. These changes allow users to build and install Hamler via standard Debian package management tools.

deploy/packages/deb · high confidence

The compiler now supports generating Erlang source code from Hamler. This change introduces the \Language.Hamler.Erlang\ module hierarchy, including \SimpleType.hs\ which defines the intermediate representation for Erlang expressions and binders, \TranslateSimpleType.hs\ which converts the internal AST to Erlang forms, \CodeGen.hs\ which handles module structure and exports, and \PrettySimpleType.hs\ for formatting. This enables users to compile Hamler programs to run on the Erlang virtual machine.

src/Language/Hamler/Erlang · high confidence

Introduced a new module, Language.Hamler.Make.Actions, which implements the logic for managing module compilation, caching, and code generation. This module handles reading module information, generating Erlang source code, and writing output files, effectively replacing or augmenting the previous build system's handling of these tasks.

src/Language/Hamler/Make · high confidence

The Hamler compiler now generates Core Erlang AST from Puresource code, enabling compilation to Erlang/OTP 24. This change adds the \CodeGen\ module which translates Hamler bindings, functions, and expressions into Erlang constructs, including support for \let\ bindings, tuple patterns, and binary pattern matching. The \Make\ module is updated to integrate this new code generation step into the build pipeline, allowing Hamler modules to be compiled to Erlang source files.

src/Language/Hamler · high confidence

A new executable script, repl/replsrv, has been added to provide a command-line REPL (Read-Eval-Print Loop) for the Hamler language. This server allows users to interactively compile and execute Hamler code, supporting commands such as 'quit' and 'help', and handles output formatting for integers, atoms, and other types.

repl · high confidence

The app directory now contains the implementation for the Hamler compiler's CLI, including commands for building, running, and testing projects, as well as an interactive REPL. This adds the core functionality for compiling Hamler source files to Erlang and executing them, with support for environment variables like HAMLER\_HOME to configure installation paths and output directories.

app · high confidence

Added the initial module for the Hamler programming language, exposing a 'hello' function and a 'version' identifier to the public API.

src/Language · high confidence

Added new experimental modules for network communication, including TCP, UDP, TLS, and DTLS, along with supporting modules for Internet (Inet) and UDP options. These modules provide FFI bindings for socket operations, allowing users to perform network I/O with features like timeouts, address parsing, and option configuration.

lib/Network · high confidence

Added a new \Control.Process\ module providing FFI bindings for Erlang process operations. This includes \Spawn\ for creating linked or monitored processes with options, \GC\ for triggering garbage collection and hibernation, \Infos\ for retrieving process metadata and message queues, \Flags\ for managing process flags like heap size and priority, \Dict\ for accessing the process dictionary, and \Proxy\ for waking up suspended processes. These additions enable users to manage process lifecycle, memory, and state directly from the host language.

lib/Control/Process · high confidence

The project now provides a unified Makefile that simplifies common development tasks. Users can run \make build\ to compile the project, \make test\ to execute the test suite, and \make install\ to install the compiler and standard libraries to a configurable home directory. The installation process automatically detects the appropriate path (e.g., \/usr/lib/hamler\ for root or \\~/.hamler\ for user-level installs) and updates the user's shell configuration to include the Hamler binaries in the PATH. Additionally, a \make repl\ target is provided to launch the interactive REPL.

(repo-wide) · high confidence

A new placeholder file and a README file were added to the doc directory. The README contains a link to the external documentation repository, providing users with a starting point for further information.

doc · medium confidence

Add comprehensive test suite for Text, System, Control, Database, and Network modules; Add tests for Term.Persistent module; Added automated tests for ETS and Mnesia database modules; Added network protocol tests for TCP and UDP; Added system-level test coverage for directory, file, error handling, and I/O operations; Added test suites for Control module components; Added tests for Reader, State, and Writer monads; Expanded test coverage for Data modules.

The project now pulls specific git revisions of the Erlang, CoreErlang, and Purescript repositories as source dependencies. Additionally, the Hamler package version has been updated to 0.5, and the build tool dependencies (such as happy) and library dependencies (including Cabal, CoreErlang, Glob, aeson, and others) have been refreshed to their latest compatible versions.

(dependencies) · high confidence

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

• CAI 50 → 53 (+3.2)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 94 → 96 (+1.9)
• Architecture 100 → 93 (-6.7)
• Maturity 43 → 57 (+13.9)
• Readiness 41 → 51 (+10.4)
• Security 46 → 40 (-5.9)
• Event Sourcing 100 → 100 (+0.0)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — no supported dependency manifest was read
• High IaC: DS-0015 (.github/dockerfile/Dockerfile.centos)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 10 more

• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (5 lines × 2) (lib/Control/Behaviour/Supervisor/Impl.erl)
• Duplicated block (5 lines × 2) (lib/Database/DETS.erl)
• Duplicated block (5 lines × 2) (lib/Database/DETS.erl)
• Duplicated block (7 lines × 2) (lib/Control/Behaviour/GenServer/Proxy.erl)
• Duplicated block (7 lines × 2) (lib/Control/Behaviour/Supervisor/Impl.erl)
• Duplicated block (9 lines × 2) (lib/Data/Pid.erl)
• High IaC: DS-0015 (.github/dockerfile/Dockerfile.centos)
• High IaC: DS-0015 (.github/dockerfile/Dockerfile.centos)
• High IaC: WD-DOCKER-0001 (.github/dockerfile/Dockerfile.centos)
• High IaC: WD-DOCKER-0001 (.github/dockerfile/Dockerfile.centos)
• High IaC: WD-DOCKER-0001 (.github/dockerfile/Dockerfile.debian)
• High IaC: WD-DOCKER-0001 (.github/dockerfile/Dockerfile.debian)
• High IaC: WD-DOCKER-0009 (.github/dockerfile/Dockerfile.centos)
• High IaC: WD-DOCKER-0009 (.github/dockerfile/Dockerfile.centos)
• High IaC: WD-DOCKER-0009 (.github/dockerfile/Dockerfile.debian)
• High IaC: WD-DOCKER-0013 (.github/dockerfile/Dockerfile.centos)
• High IaC: WD-DOCKER-0013 (.github/dockerfile/Dockerfile.debian)
• High: security finding (details withheld)
• …and 46 more

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

hamler-lang/hamler 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.