> ## Documentation Index
> Fetch the complete documentation index at: https://hypotenuse.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Compiler Status: Implemented and Unimplemented Features

> Track which C△ language features are implemented in the current Hypotenuse Compiler and which are still in progress.

The C△ language specification describes the full design of the language. The Hypotenuse Compiler is still under active development, so not every documented feature is wired up yet. This page is the authoritative list of what the current compiler does and does not implement.

<Note>
  Documentation pages describe the language as designed. Where a feature is not yet implemented, you will find an inline notice on the relevant page linking back here.
</Note>

## Implemented Features

The features below are wired up and working in the current compiler. Everything else documented elsewhere in this site describes the **language design** and is not yet supported — see [Unimplemented Features](#unimplemented-features) below.

### Inline assembly

* `asm` functions and anonymous `asm {}` blocks
* `syntax` and `section` directives
* The NASM + GCC link pipeline

<Warning>
  Assembly is supported on **Linux (x86\_64)** and **macOS (ARM64)** only. **Windows is not supported for `asm`** — the MSVC build path does not invoke NASM, so any source containing `asm` will fail to produce a working binary on Windows.
</Warning>

### Module system and libraries

* `using <lib>` and `using symbol from <lib>` — including the library-name rewrite when importing a single symbol.
* `using symbol as alias from <lib>` — aliasing on import.
* `expose` — globalize a library's symbols into the current scope.
* `space { ... }` — declare a named namespace.
* `function@namespace(...)` — explicit namespace access without exposing.
* `.plib` library importing and resolution from the standard `PLIBS/` search paths.

### Types and collections

* The first-class `string` type
* `dynam` arrays, including list-literal initializers and runtime growth
* The `len()` built-in for `string` and `dynam`

### Memory

* `allocate` — manual heap allocation, including the custom-size syntax (e.g. `allocate int buf[N]`).
* `free` — manual deallocation.

### Standard library (`plstd`)

* `printd.plib` — type-aware single-value printing (`printd`).
* `string.plib` — the plstd string library (`strcmp`, `strcpy`, `strcat`, `strlen`, `strdup`, `strchr`, `strstr`, `strncpy`, `strncat`, `strncmp`).
* `streamer.plib` — file I/O.

### C11 baseline

All C11 language features inherited by C△ work as documented — primitives, pointers, structs (fields only), unions, enums, `typedef`, control flow, and functions.

## Platform Support

| Platform          | Status                              | Notes                                                                                                                                                                                                        |
| ----------------- | ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Linux (x86\_64)   | Fully supported                     | `hypotenuse -c` produces a linked native binary end-to-end.                                                                                                                                                  |
| macOS (ARM64)     | Fully supported                     | `hypotenuse -c` produces a linked native binary end-to-end.                                                                                                                                                  |
| Windows (x86\_64) | Technically supported, manual build | The compiler emits portable C (`.c`) output, but cannot invoke MSVC for you. You must run `cl.exe` (or equivalent) yourself on the generated C. **`asm` blocks and `asm` functions do not work on Windows.** |

## Unimplemented Features

Everything documented across the site that is **not** listed in the Implemented Features section above is not yet supported. The list below calls out the most prominent gaps so you don't reach for them by accident.

| Feature                                                                                                     | Status          | Notes                                                                                                                                         |
| ----------------------------------------------------------------------------------------------------------- | --------------- | --------------------------------------------------------------------------------------------------------------------------------------------- |
| `auto` (inferred / dynamic type)                                                                            | Not implemented | Type inference and multi-variable packing with `auto` are part of the language design but not yet wired up.                                   |
| `tuple`                                                                                                     | Not implemented | Heterogeneous dynamic lists, `.push()`, and `len()` on tuples are not yet supported.                                                          |
| `struct` extensions (`init`/`end`, member functions, plain struct constructors, `typed struct` inheritance) | Not implemented | Only standard C11 struct declarations (fields only) work. Constructors, destructors, member functions, and inheritance are not yet supported. |
| `lamb` (named lambdas)                                                                                      | Not implemented | Inline lambda declarations are not yet supported.                                                                                             |
| `autoremove`                                                                                                | Not implemented | The simulation pass does not yet perform last-use analysis or insert automatic `free` calls.                                                  |
| Robbery                                                                                                     | Not implemented | Ownership transfer between `autoremove` bindings depends on `autoremove` and is not yet supported.                                            |
| `printfs` (formatted / f-string print)                                                                      | Not implemented | `printd` ships in `printd.plib`, but `printfs` and its `{expr}` / `%`-style formatting are not yet available.                                 |

<Note>
  Documentation pages describe the language as designed. Where a feature is not yet implemented, you will find an inline notice on the relevant page linking back here.
</Note>

## Reporting Gaps

If you hit a feature that is documented but does not behave as described — and is not listed in the Unimplemented Features table above — please file an issue against the compiler repository so we can either fix the compiler or update this page.