fika-lang/fika

Fika is a domain-specific language and runtime built on the Erlang VM, designed to compile source files into BEAM bytecode for execution via a command-line interface or a web server. The system provides a complete compiler pipeline that parses Fika syntax, performs static type checking with support for unions and effects, and generates Erlang code. It features a router mechanism that supports hot-reloading of HTTP route definitions, allowing developers to iterate on web services without restarting the application.

A new example file (examples/router.fi) has been added to demonstrate how to define HTTP routes using a list of records containing method, path, and handler fields. The example includes simple handlers for the root path and a /foo path, illustrating the use of record syntax in the language.

examples · high confidence

The Fika compiler now provides a complete pipeline for compiling source files into Erlang BEAM bytecode. This includes a parser for the Fika language, a type checker that supports function signatures, type inference, and subtyping, and an Erlang translator that converts the abstract syntax tree into Erlang forms. The system uses a central CodeServer (GenServer) to manage compilation state, store type information, and handle parallel compilation of modules. Default type signatures for kernel operations (arithmetic, comparison, logic) and list operations (map, filter, reduce, length) are included, along with support for external function calls and effect types.

lib/fika/compiler · high confidence

The application now includes a standard Elixir configuration setup with environment-specific files (dev, test, prod, releases). This introduces the \:fika\ application configuration, allowing users to define the router path (e.g., \examples/router.fi\ in dev, \router.fi\ in prod) and control runtime behaviors such as disabling the web server in test mode or enabling CLI start in release mode. Environment variables like \FIKA\_DEV\_TOKEN\ and \FIKA\_REMOTE\_ENDPOINT\ are now supported for release configurations.

config · high confidence

The \lib/fika/compiler/parser\ module now provides the foundational grammar for the Fika language, enabling the compiler to parse source code into an Abstract Syntax Tree (AST). This implementation supports defining public and external functions, handling expressions including arithmetic, logical, and comparison operators, and managing control flow via \if-else\ and \case\ expressions. It also introduces support for anonymous functions, record and map literals, and a type system featuring base types, union types, and effect types. Additionally, the parser allows identifiers to start with keywords (with specific exceptions) and permits comments between expressions.

lib/fika/compiler/parser · high confidence

Establishes the foundational structure for the Fika language project by adding configuration files for Elixir formatting (.formatter.exs), Git attributes (.gitattributes), and environment versions (.tool-versions). Includes a comprehensive README.md detailing installation, usage via the Elixir shell or CLI, and web server setup, alongside an example.fi file demonstrating the language's syntax features such as functions, types, and operators.

(repo-wide) · high confidence

This change introduces the core Fika language runtime, including a CLI for executing code and a web server for handling HTTP requests. Users can now run Fika scripts via the command line, define routes in .fi files, and benefit from automatic reloading of routes when source files change. The release also includes a deployment helper to package the executable and establishes the foundational OTP application structure with a supervisor, code server, and file watcher.

lib/fika · high confidence

Users can now use new list manipulation functions (map, reduce, filter, length) and an IO effect module (gets, puts) in Fika code. These are implemented as external bindings to Elixir's Enum and IO modules. A new Mix compile task is also added to handle compilation of .fi files.

fika, lib/mix · high confidence

The type checker now includes dedicated modules for representing specific data structures, including Effect, FunctionRef, List, Map, Record, Tuple, and Union types. These modules provide structured data definitions and string formatting implementations, enabling the compiler to accurately model and display complex type signatures during static analysis.

_lib/fika/compiler/type\checker/types · high confidence

The release environment scripts (rel/env.bat.eex and rel/env.sh.eex) now explicitly set RELEASE\_DISTRIBUTION=none, ensuring that the CLI application runs as a standalone node without attempting to start an Erlang distribution. This prevents unintended network connectivity or clustering behavior when running the command-line interface.

rel · high confidence

The router now supports hot-reloading of routes without requiring a full application restart. A new \Fika.Router.Store\ module manages route definitions in an Agent, allowing routes to be loaded from a specified file and reloaded on demand. The \Fika.Router.Supervisor\ initializes this store and starts the web server (Plug.Cowboy on port 9090), ensuring that changes to the router configuration file are reflected immediately in the running application.

lib/fika/router · high confidence

The type checker now processes function signatures in parallel using a GenServer-based architecture (ParallelTypeChecker) to improve compilation performance, while also introducing a new FunctionMatch module that correctly handles function subtyping during signature resolution. Additionally, a new Match module implements pattern matching logic for type checking, supporting unions, tuples, and records.

_lib/fika/compiler/type\checker · high confidence

Added comprehensive test coverage for the Fika compiler; Added test support modules for parser and evaluator; Initial test infrastructure setup.

The Fika application is initialized with a new mix project configuration and lock file, establishing the foundational dependencies required for the system. This includes nimble\_parsec for parser combinator functionality, plug\_cowboy for the web server, file\_system for file watching and auto-reloading, finch for HTTP client operations, jason for JSON handling, and bakeware for release assembly. The project also specifies Elixir version 1.10 as a requirement.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 56.

• Code Health 97
• Architecture 100
• Maturity 43
• Readiness 55
• Security 66

• 95 commits — 93 feature/other, 2 fixes

• lib/fika — 57 commits
• (root) — 27 commits
• test/fika — 3 commits
• .github/workflows — 2 commits
• docs/hacking_syntax.md — 2 commits
• test/support — 2 commits
• (repo) — 1 commit
• rel/env.bat.eex — 1 commit

• fix: Fix string interpolation compilation (#48)
• fix: Parser fixes (#44)
• change: Acknowledge FOSSUnited's support in README
• change: Add CLI to exec Fika code
• change: Add README with a short description
• change: Add TestEvaluator helper module (#38)
• change: Add anonymous functions (#58)
• change: Add back tinyletter URL
• change: Add boolean data type (#6)
• change: Add case expression (#67)
• change: Add comparison operators for Int (#42)
• change: Add doc for contributing to Fika syntax
• change: Add effect type and IO module (#57)
• change: Add function arguments with types
• change: Add if-else expression (#14)
• change: Add link to discord server in README
• change: Add links to images
• change: Add lists
• change: Add logical operators (#28)
• change: Add logo
• …and 75 more

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

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