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.
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;
}
}Camp brings back the features you want from higher-level languages, while maintaining a low-effort, obvious, and highly readable syntax.
Camp aims to be a good citizen among other languages, with constructs that work beautifully across the C ABI.
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.
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.
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.