A modern C-like language that actually feels like C.

Camp combines familiar syntax with real ergonomics: interfaces, generics, async, generators, and more, all designed to lower into native code through clean, idiomatic C interfaces.

But is Camp safe? Of course it isn't safe. It's good.

export int main()
{
    Console.writeLine("Hello, Camp.");
    return 0;
}
interface ValueSource
{
    int read();
}

class Counter: ValueSource
{
    int value;

    Counter(int value)
    {
        this.value = value;
    }

    int read(): ValueSource => this.value;
}

export int main()
{
    auto counter = new Counter(42) finally delete;
    printValue(counter);
    return 0;
}

void printValue(ValueSource* source)
{
    Console.writeLine(source.read());
}
export void main()
{
    auto greeter = new Greeter("Camp") finally delete;
    greeter.greet();
}

class Greeter
{
    string name;

    Greeter(unscoped string name)
    {
        this.name = name;
    }

    void greet(const this)
    {
        Console.writeLine($"Hello, {this.name}");
    }
}
export int main()
{
    // Print even values
    foreach (auto value in iterateMatches(n => n % 2 == 0))
    {
        Console.writeLine(value);
    }

    return 0;
}

struct iter uint iterateMatches(delegate bool(uint value) predicate)
{
    for (uint value = 1; value <= 10; value++)
    {
        if (predicate(value))
            yield value;
    }
}

The syntax sugar you wish C had.

Camp brings back the features you want from higher-level languages, while maintaining a low-effort, obvious, and highly readable syntax.

Interop as a first-class concern.

Camp aims to be a good citizen among other languages, with constructs that work beautifully across the C ABI.

Light weight, baby.

Camp has no garbage collector and no managed platform to buy into, just a lightweight static runtime and explicit native integration.

This language comes with a workbench.

Camp is more than just a compiler.

Tests, coverage, editor integration, target definitions, and planned package management belong in the same story as the language. Camp is growing its own facilities for the everyday work around native software.

Tests and coverage close to the compilerDiscover tests, run them, and see coverage against Camp source without a separate tool.
Editor support that knows the projectSyntax highlighting, language services, debugging, test commands, and coverage views can follow the same compiler model.
Targets that say what machine you meanTarget files describe C compilers, calling conventions, pointer widths, profiles, and variants for modern, old, embedded, 16-bit, 32-bit, and 64-bit builds.
Package management (planned)The compiler already exercises package API headers and artifact caching internally; public package distribution is still being designed.

Curious? Start with the language guide.

The docs explain Camp as a language for writing native code, then connect that source model to compiler behavior, standard library APIs, tooling, and more.

Browse Docs