# Show HN: Jik – a self-hosted language using region-based memory management

> Source: <https://github.com/jik-lang/jik>
> Published: 2026-11-01 19:51:54+00:00

*A readable, statically typed language that compiles to C and manages memory with regions.*

*Open a ready-to-use Jik development environment.*

Jik is a statically typed programming language with a straightforward source-to-C compilation model. It avoids both garbage collection and manual heap allocation.

It provides type inference, optional type annotations, vectors, dictionaries, options, variants, exhaustive enum/variant tables, error handling, a standard library, and a growing package ecosystem. The result is concise source code and predictable generated C.

Jik's defining idea is its memory model: composite values are allocated into regions that determine their lifetime, while compiler checks prevent references across regions with incompatible lifetimes.

## **Hello, Regions!**

Functions that return composite values let the caller choose the destination region:

``` php
func default_actions(r: Region) -> Vec[String]:
    return ["Open", "Save", "Quit"][r]
end

func main():
    actions := default_actions(_)
    println("first action: ", actions[0])
end
```

`_` is the current function's local region. For a longer-lived result, pass an explicit `Region` or the region of another composite value.

## **Parsing a config**

```
use "jik/string"

func main():
    text := "host = localhost\nport = 8080\nmode = dev\n"
    settings: Dict[String]

    for line in string::split(text, "\n", _):
        parts := string::split(line, "=", _)
        if len(parts) != 2:
            continue
        end
        key := string::trim(parts[0], _)
        value := string::trim(parts[1], _)
        settings[key] = value
    end

    host := settings["host"]
    port := settings["port"]
    if host is Some and port is Some:
        println("connecting to ", host?, ":", port?)
    end
end
```

## **Error handling**

```
throws func safe_div(x, y):
    if y == 0.0:
        fail("division by zero")
    end
    return x / y
end

func show_div(x, y):
    try value := safe_div(x, y):
        println(x, " / ", y, " = ", value)
    except:
        println("cannot divide ", x, " by ", y, ": ", error_msg())
    end
end

func main():
    show_div(12.0, 3.0)
    show_div(7.0, 0.0)
end
```

To start programming in Jik:

- [download the latest release](https://github.com/jik-lang/jik/releases/latest) for your platform
- extract the release archive
- add the extracted directory to `PATH`
- from the extracted directory, run `jik help` to confirm the executable works
- `jik run` and`jik build` require a C compiler. Jik automatically looks for`clang` ,`gcc` , then`cc` on`PATH` .
To select a specific compiler, use the`--cc` flag or set the`JIK_CC` environment variable.
  - Windows tip: For a simple GCC setup, download from [WinLibs](https://winlibs.com/) , and add its`bin` directory to`PATH`
- Windows tip: For a simple GCC setup, download from 
- run the included hello example: `jik run examples/hello.jik`
- generate C output: `jik tran examples/hello.jik`
- build an executable: `jik build examples/hello.jik`

Only `gcc` and `clang` host compilers were tested. MSVC was not tested.

See the [examples](https://github.com/jik-lang/jik/blob/main/examples) directory for [variants](https://github.com/jik-lang/jik/blob/main/examples/variants.jik), [tables](https://github.com/jik-lang/jik/blob/main/examples/tables.jik), more [error handling](https://github.com/jik-lang/jik/blob/main/examples/error_handling.jik), [word count](https://github.com/jik-lang/jik/blob/main/examples/word_count.jik), [Dijkstra](https://github.com/jik-lang/jik/blob/main/examples/dijkstra.jik), [Newton's method](https://github.com/jik-lang/jik/blob/main/examples/newton.jik), [Game of Life](https://github.com/jik-lang/jik/blob/main/examples/game_of_life.jik), [Forth](https://github.com/jik-lang/jik/blob/main/examples/forth.jik), and [C interop](https://github.com/jik-lang/jik/blob/main/examples/ffi_demo.jik).

[Jik packages](https://github.com/jik-lang/jik-packages) provide reusable libraries and C bindings for writing larger programs.

- [Play Missile Defence](https://jik-lang.org/showcase/missile-defence/) — a Jik game built with the[Raylib wrapper](https://github.com/jik-lang/jik-packages/tree/main/packages/raylib) .
  - [Source code](https://github.com/jik-lang/jik-packages/tree/main/packages/raylib/examples/missile_defence)
  - Note: the browser demo is a separate WebAssembly build

You need Make and Clang or GCC. From the repository root:

```
make                       # Build jik
make test                  # Build and run the tests
make help                  # Show build commands
```

Use `make CC=gcc` to build with GCC; Clang is the default. The build uses the
bundled C seed, so you do not need to download a Jik compiler. See the
[development notes](https://github.com/jik-lang/jik/blob/main/docs/development.md) for bootstrap stages and release builds.

Download `jik-language-tools-*.vsix` from the [latest release](https://github.com/jik-lang/jik/releases/latest). In VS Code, open the Extensions view, select the `...` menu, choose **Install from VSIX...**, and select the downloaded file.

The extension provides syntax highlighting, import-aware standard-library completion, and hover documentation and signatures.