Language Surface
Generics, interfaces, enums, ownership, async, and project mode
Start from the capabilities Arden already ships instead of guessing from the repo layout.
Workflow
Installation, quick start, projects, testing, and CLI reference
Use the docs as a product map: install it, run it, then move into project mode and tooling.
Arden Overview
Arden is a native systems programming language built around three priorities:
- fast compiler feedback
- strong static guarantees
- a practical all-in-one developer workflow
It targets LLVM for native code generation and ships with its own formatter, linter, test runner, benchmark command, bindgen command, and project CLI.
This page is the best starting point if you want to understand what Arden already is, what the repository actually ships today, and where to go next.
At A Glance
Arden already ships more than "parse a file and hope for the best".
Current repository surface:
| Area | What is already there | Start here |
|---|---|---|
| Language core | static types, functions, lambdas, control flow, modules | Syntax, Types, Functions |
| Structured types | classes, interfaces, enums, visibility, inheritance | Classes, Interfaces, Enums |
| Reusable typing | generics, generic bounds, generic interfaces, nested generic types | Generics, ../examples/09_generics.arden |
| Safety model | ownership, borrowing, checked mutation, static validation | Ownership, Memory Management |
| Concurrency | async, await, Task<T> |
Async, ../examples/14_async.arden |
| Workflow | new, check, run, fmt, lint, fix, test, bench, profile, bindgen, lsp |
Quick Start, Compiler CLI |
| Project mode | arden.toml, multi-file builds, project-aware tooling, cache state |
Projects, Projects Summary |
| Runtime surface | stdlib intrinsics such as io, math, time, args, collections, system |
Stdlib Overview |
What Arden Can Already Do
If you are evaluating the language, these are the capabilities you should assume exist today:
- compile and run both single files and explicit multi-file projects
- type-check static signatures before code generation
- model reusable APIs with generic functions, generic classes, and bounded type parameters
- express interface-based polymorphism with
implementsandextends - model branching data with enums and use pattern matching over them
- use async tasks with typed results via
Task<T> - use ownership and borrowing rules to catch invalid moves and mutation hazards earlier
- call common workflow commands from one CLI instead of stitching together unrelated tools
- use built-in container/result surfaces such as
Option<T>,Result<T, E>,List<T>,Map<K, V>, andSet<T> - use formatter, linter, test discovery, benchmark commands, profile commands, bindgen, and LSP support from the same repo
The fastest proof is usually to read one prose page and one runnable example side by side:
- Generics +
../examples/09_generics.arden - Ownership +
../examples/10_ownership.arden - Async +
../examples/14_async.arden - Projects +
../examples/starter_project/README.md
What Arden Tries To Be
Arden is not aiming to be minimal for its own sake, and it is not trying to hide systems-level constraints behind a giant runtime.
The current direction is:
- explicit enough to make ownership, mutation, and types visible
- ergonomic enough for day-to-day app and tool code
- integrated enough that common workflows are built into the compiler CLI
In practice that means Arden sits closer to "systems language with batteries included" than to "minimal compiler experiment". The repo does not just compile a file; it includes project mode, formatter/linter flows, test discovery, benchmarking commands, and example sweeps.
What You Can Learn Here
The repository is organized so different readers can enter at different depths:
- if you want syntax and language features, stay in
basics/andfeatures/ - if you want workflow, use
getting_started/andcompiler/cli.md - if you want runtime facilities, use
stdlib/ - if you want to see real code first, jump to
../examples/README.md - if you want compiler internals, read
compiler/architecture.md
Core Concepts
Static Types
Arden is statically typed. Variables, function signatures, generics, and collection element types are checked ahead of code generation.
Relevant docs:
Ownership And Borrowing
Arden includes ownership and borrowing checks to catch invalid moves, aliasing mistakes, and mutation hazards before runtime.
Relevant docs:
Project Mode
Single-file workflows are supported, but Arden also has a real multi-file project mode based on arden.toml.
Project mode includes:
- explicit file lists
- project-aware
build,run,check,test,fmt, andinfo - build caching and timing output
Relevant docs:
Built-In Workflow Commands
Arden intentionally keeps common tasks under one CLI instead of expecting separate ad-hoc tools for each stage. In current repository form, that includes:
- project creation with
arden new - checking and building with
arden check,arden build, andarden run - formatting and linting with
arden fmt,arden lint, andarden fix - test discovery with
arden test - simple performance inspection with
arden benchandarden profile - C binding generation with
arden bindgen
Native Toolchain Output
Arden lowers to LLVM IR and then produces native artifacts using Clang plus a platform-specific linker policy.
Relevant docs:
Language Features Available Today
The current compiler surface includes:
- functions and lambdas
- classes, interfaces, inheritance, and visibility
- enums and pattern matching
- generics and generic bounds
- modules, packages, and imports
Option<T>andResult<T, E>- async / await with
Task<T> - intrinsic stdlib modules such as
Math,Str,Time,System,Args, and file I/O helpers - built-in test attributes such as
@Test,@Before, and@Ignore
Feature Map
Use this as the short index when you want to jump directly to a capability instead of reading the docs in order.
Core Syntax And Type System
Reusable Abstractions
Safety And Runtime Behavior
Tooling And Workflow
For a broad but runnable tour of these features, the examples directory is often faster than prose:
../examples/17_comprehensive.arden../examples/24_test_attributes.arden../examples/35_visibility_enforcement.arden../examples/showcase_project/README.md
CLI Workflow
Arden intentionally bundles common workflows into one CLI:
new, build, run, compile, check, info, lint, fix, fmt,
lex, parse, lsp, test, bindgen, bench, profile
Reference:
Suggested Learning Paths
Path 1: I Want To Run Something In Five Minutes
Path 2: I Want To Understand The Language Surface
Path 3: I Want To Contribute To The Compiler
Suggested Reading Order
If you are new to the language:
If you want real code quickly:
Accuracy Policy
The source docs in this repository are meant to describe the current compiler, examples, and CLI behavior. If you notice a mismatch between docs and reality, the intended fix is to update the documentation or example corpus rather than leave contradictory material around.