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;
}export int main()
{
string text = File.readAllText("notes.txt", catch error);
if (error != default)
return 1;
foreach (string line in text.lines())
{
if (line.indexOf("camp", caseInsensitive: true) >= 0)
{
Console.writeLine(line);
}
}
return 0;
}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.write("Hello, ");
Console.writeLine(this.name);
}
}export int main()
{
// Print even values
foreach (auto value in iterateMatches(n => n % 2 == 0))
{
Console.writeLine(value);
}
return 0;
}
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.
Packages, tests, coverage, editor integration, and target definitions belong in the same story as the language. Camp comes with its own facilities to handle the everyday tasks of writing software.
The docs explain Camp as a language for writing native code, then connect that source model to compiler behavior, standard library APIs, packages, and more.