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;
}
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;
	}
}

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.

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.

Package managementUse package sources, local references, API headers, and metadata without turning the build into a scavenger hunt.
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.

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, packages, and more.

Browse Docs