Conjure is a systems programming language and toolchain designed for creating games, engines, and game-development tools. It is a statically typed, compiled language with a focus on performance, developer experience, and developer freedom.
We’re building Conjure with a “tooling-first” philosophy, which means we prioritize building great tools and editor integrations alongside the language itself. This approach takes a bit longer, but results in a more cohesive development experience from day one.
Some examples of first-class features that our tooling provides:
- Hot reload built into the compiler
- Cross-compilation with zero configuration
- Testing and benchmarking included
- Code formatting that relies on official language opinions
- Documentation generation from your code
- Asset embedding with optional sidecar files for modding support
Current Status
The language is still in the early stages of development with many syntax and semantic decisions still being made. However, we’re actively working on the re-implementation of the finalized feature set in Conjure, as self-hosting is a critical aspect to key features (namely compile-time execution).
Compilation Pipeline
Conjure currently compiles (or more correctly, “transpiles”) to C99 code, giving you access to decades of optimization work, extensive libraries, and full cross-platform support.
Our worst-case scenario is being C with an updated syntax and more manageable tooling. In the future, we plan to add an LLVM backend for even more optimization opportunities, along with web targets like WebAssembly and JavaScript.
Another benefit of compiling directly to C is that we can call C functions with zero overhead. This means we can leverage existing C libraries and even use C code directly in our projects without any wrappers or bindings.
The Conjure SDK ships with a modified version of TinyCC (TCC) for fast compilation during development, but is able to use any C compiler you have installed, including Clang and GCC. When building for release, Conjure will automatically attempt to locate and use an existing C compiler (favoring Clang) on your system before falling back to TCC with a warning.
Developer Ergonomics Matter
Inspired by Go and Zig, we’ve carefully chosen our syntax to minimize keystrokes and keep your fingers on the home row. Every keyword, every operator has been considered for how it feels to type hundreds of times a day. This is why the language currently lacks colons between names and types and why we use keywords like and and or instead of && and ||.
Additionally, keyword operators like and, or, and not improve readability, making it easier to understand complex expressions at a glance. When you see an &, you’ll know it’s because you’re working with a lower-level concept like pointers/references or bitwise operations.
Compilation times hinder the developer experience further, which is why we’re extremely focused on performance and incremental builds. Our goal is to have a full rebuild take less than a few seconds when compiling on modern hardware, with near instantaneous rebuilds when making small changes.
Compile-Time
Borrowing from a wave of modern languages (namely Zig), Conjure plans to support powerful compile-time features, including full compile-time code execution and reflection.
Compile-time execution is implemented by “pre compiling” your code to a shared library that the compiler can load and execute at final compilation time. This extends to the language server as well, enabling features like code generation, static assertions, custom intellisense hints, and so on.
This compile-time execution model is a critical aspect to the success of features important to game development, such as processing and embedding assets or pre-compiling shaders for target platform (namely SPIR-V).
Speaking of shaders, Conjure is able to compile GLSL, HLSL, and SPIR-V shaders directly from a subset of Conjure source code. This means you can avoid context switching between languages while working on your game and see your shaders co-located to relevant game logic that may interact with them.
Standard Libraries
We provide two standard libraries within Conjure. One is designed to be a general purpose library that the language itself depends on, while the other is focused on game development with a set of higher-level abstractions and opinions.
Language-critical functionality: strings, collections, math, file I/O, JSON, serialization, and more.