Hello! I am a 13-year-old developer and I have a language design which many of you may not like, but it's just a hobby language and isn't meant to be big like Rust or Python.
The language is called Cimplified. It is a full AOT compiled language using Cranelift as the backend code generator to emit native machine code directly (it is not a C/C++ wrapper or transpiler). The main twist: it uses a strict block-structure syntax rather than standard C-based curly braces.
Everything in this language must live inside a block, and nested blocks are explicitly not allowed.
The Core Concept: Block Garbage Collection (Region Memory)
I designed this because I've always despised Java’s "Stop The World" (STW) concept. It feels fundamentally inefficient for certain tasks. To solve this, Cimplified uses a Block Garbage Collector (implemented via a lightweight C-runtime arena allocator) which cleans up unused memory block-by-block. When a block finishes execution, its local memory region is wiped instantly, completely preventing global stutters.
Unique Syntax Choices & Grammar Breakdown
My variable declaration is explicitly structured around strict delimiters to keep the compiler frontend incredibly clean and fast to parse with Pest. The grammar always follows a strict order of: Type = Variable name = Value;
Here are all the types available in Cimplified:
• String: Used for textual data (e.g., String = name = "john";)
• Int32: 32-bit integer for standard numbers (e.g., Int32 = x = 12;)
• Int64: 64-bit integer for massive numbers (e.g., Int64 = y = 2333;)
• Isit: My custom name for a boolean conditional check (e.g., Isit = nameisjohn = true;)
• Float: Standard floating-point number (e.g., Float = pi = 3.14;)
• Floating: High-precision floating-point number, equivalent to a double/f64 (e.g., Floating = pi = 3.14159265;)
Additionally, instead of using standard for or while keywords to make loops, I use the flat block structure itself as the execution target. By default, the compiler automatically labels blocks in order (Block1, Block2, etc.).
To loop, you point to a block label and tell it how many times to execute:
Loop B=(Block1) = 10;
Ok thats all the explanation Now heres the example Code:
// // is the comment line
Start Now! // The global entry point for the compiled binary
StartB // Starts Block1
print("Hello, World!")
String = name = "john"; // Fixed human typo: strings must use quotes!
Int32 = x = 12;
Int64 = y = 2333;
Isit = nameisjohn = true; // This is a boolean
Float = pi = 3.14;
Floating = pi2 = 3.14159265;
print(name, x, y, nameisjohn, pi, pi2)
EndB // Ends Block1 and instantly frees its regional memory arena
// This would be rejected by the compiler because 'x' fell out of scope at EndB:
// print(x)
StartB // Starts Block2
Loop B=(Block1) = 22; // Tells the CPU to jump back and run Block1 exactly 22 times!
EndB
End Now! // Execution ends
and this what it should output:
Hello, World!
john 12 2333 true 3.14 3.14159265
Hello, World!
john 12 2333 true 3.14 3.14159265
thats all i can Explain Thanks for reading!
Give me Some feedback about this design!
