Home Original page

GitHub - omdxp/fun: Fun is a statically-typed language that transpiles to C, combining safety and performance with C's efficiency.

Fun Programming Language

CI License: MIT

Fun is a statically-typed programming language that transpiles to C, designed for safety, performance, and simplicity. Written in Zig. Fun includes high-level defaults (num, dec) and low-level fixed/arbitrary-width numeric types (i32, u64, f32, f64, iN, uN).

Table of Contents

Features

  • Statically-typed, C-like performance
  • Rich numeric model (num/dec, fixed-width i32/u64, and arbitrary-width iN/uN)
  • Transpiles to readable C code
  • Simple, expressive syntax
  • Modular imports
  • Pattern matching (fit statement)
  • Type-safe variables and functions
  • CLI with multiple output and debug options
  • AST printing and analysis
  • Comprehensive error handling
  • Example and test suite

Installation

Requires Zig (v0.14.0+ recommended).

This will build the fun compiler in zig-out/bin/fun.

To install the compiler plus the Fun standard library files:

This installs:

  • zig-out/bin/fun
  • zig-out/share/fun/stdlib/std/c/*.fn (signature-only C-interop modules used for tooling)

Notes:

  • std.c.* is the C-interop layer (signatures only). These modules describe external C APIs (e.g. printf) so the compiler and language server can typecheck and provide tooling.
  • std.* (without .c) is intended for Fun-native standard library modules written in Fun.

Release installers (bundles)

Release assets are packaged as install bundles (binary + share/fun/ + an installer script).

On Windows, release assets are provided as .msi installers.

The compiler discovers the standard library at runtime using, in order:

  • FUN_STDLIB_DIR (explicit override)
  • <exe>/../share/fun (installed layout)
  • common system locations (platform-dependent)

GitHub Actions

Use the published setup action to install fun in CI:

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: omdxp/setup-fun@v1
        with:
          version: latest
      - run: fun -version

CLI Usage

Usage: fun -in <input_file> [-out <output_file>] [-no-exec] [-outf] [-ast] [-help]

Arguments:
  -in      <file>  Input file to compile (required)
  -out     <file>  Output file (optional, defaults to input filename with .c extension)
  -no-exec         Disable automatic compilation and execution (optional, execution enabled by default)
  -outf            Generate .c output file (optional, disabled by default)
  -ast             Print AST nodes (optional, disabled by default)
  -help            Show this help message

C Compiler Selection

By default, fun tries platform compiler defaults unless FUN_CC is set:

  • Windows: zig cc, clang, gcc, cl
  • macOS/Linux: zig cc, clang, gcc, cc

Release installers on macOS/Linux set FUN_CC=gcc by default. The Windows MSI sets FUN_CC to use cl with a template command. You can override the C compiler with environment variables:

  • FUN_CC: compiler command. If it includes {src} and {out}, it is treated as a full template.
  • FUN_CC_ARGS: extra arguments appended after the base command.

Examples:

  • Use clang:
    • FUN_CC=clang
  • Use zig cc explicitly:
    • FUN_CC=zig and FUN_CC_ARGS="cc"
  • Use a template with explicit placeholders:
    • FUN_CC="clang -O2 {src} -o {out}"

Windows notes

If you use cl, run fun from Developer PowerShell for Visual Studio (or after VsDevCmd.bat) so MSVC environment variables are initialized.

Recommended stable setup on Windows:

$env:FUN_CC = "zig"
$env:FUN_CC_ARGS = "cc"

Use cl explicitly only when your VS toolchain shell is active:

$env:FUN_CC = "cl /nologo /Fe{out} {src}"
$env:FUN_CC_ARGS = ""

If cl compiles but runtime output looks wrong on your system/toolset, switch back to zig cc.

Quickstart

Write your first program in hello.fn:

imp std.c.io;

fun main(str[] args) {
  printf("Hello, World!\n");
}

Compile and run:

zig build
./zig-out/bin/fun -in hello.fn

Examples

Explore the examples/ directory for more:

Documentation

Project Structure

  • cmd/ — CLI entrypoint
  • modules/ — Core compiler modules (lexer, parser, codegen, semantics, utils, etc.)
  • examples/ — Example programs
  • tests/ — Test suite
  • build.zig — Zig build script

Contributing

Contributions are welcome! Please open issues or pull requests. See CONTRIBUTING.md if available.

Changelog

See CHANGELOG.md for release notes and development history.

License

This project is licensed under the MIT License. See the LICENSE file for details.

IDE / Language Server (fls)

This repo includes a work-in-progress language server called fls.

  • Build: zig build (installs fls alongside fun)
  • The server speaks LSP over stdio and currently supports:
    • Diagnostics (via fun -no-exec)
    • Formatting (via fun -fmt -no-exec)

VS Code

There is a minimal VS Code extension scaffold in editors/vscode.

  • Build fun + fls first (zig build)
  • Then open editors/vscode in VS Code and follow its README.

Other Editors

See editors/README.md for Vim/Neovim, Emacs, JetBrains, and Sublime setup.

GitHub Syntax Highlighting

This repo maps .fn files to Zig highlighting on GitHub via /.gitattributes. For native Fun highlighting, submit a Fun definition + TextMate grammar to GitHub Linguist.

Installation

Prerequisites

Build from Source

Clone the repository and build using Zig:

git clone https://github.com/omdxp/fun.git
cd fun
zig build

Install from Release

Pre-built installers and binaries are available for each release. See Release installers (bundles).