Quidra Maximum Meaning Per Token

int count = 3

a typed binding with familiar declaration syntax

auto name = "Quidra"

infer a type when the initializer makes it unambiguous

for value in values

iterate directly over values

Point(3.0, 4.0)

construct a value by calling its type

=

ordinary assignment has independent value semantics

&x

observable aliasing is requested explicitly

T(value)

representation changes are explicit

and / or / not

boolean logic uses readable words

The deeper safety rules stay out of ordinary code until they matter: copies remain independent, aliasing is requested explicitly, representation changes are written down, and visible names cannot be silently shadowed.

1. 01

   Values are the default; storage is explicit.

   Ordinary = means an independent value. Observable aliasing is written with &: a T & path can write, a const T & path can only observe. The implementation may share storage or copy on write only when the difference cannot be observed.

   int[] a = [1, 2, 3]
   int[] b = a
   b[0] = 9
   print(a[0])
   print(b[0])
   
   int x = 1
   int &writer = &x
   const int &view = &x
   writer = 5
   print(view)

   output

   1
   9
   5

2. 02

   Authority is part of the call.

   A reference parameter makes caller-owned storage access explicit, and the parameter decides whether that path may write. The checker tracks what a call requires to be initialized and what it guarantees afterwards, so a writable parameter can safely initialize storage.

   void inspect(const int &value)
       print(value)
   
   void initialize(int &value)
       value = 7
   
   int value
   initialize(&value)
   inspect(&value)

   output

   7

3. 03

   State facts are tracked, not guessed.

   Uninitialized does not mean zero, none or a hidden default. Definite initialization is followed through branches, loops, references, fields, calls and returns; a class may be intentionally partial, and reading the missing part is rejected before the program runs.

   int x
   print(x)

   quidra check uninitialized.qui

   uninitialized.qui:2:7: error[UNINITIALIZED] Binding 'x' may be uninitialized.
   1 error(s) generated.

4. 04

   Representation changes are explicit.

   An already-typed numeric value never changes representation implicitly, even when the conversion would be lossless. Casts use the destination type and integer narrowing is range checked. Floating-point to integer is not a generic cast, because the rounding is the meaning: say math.round, math.floor, math.ceil or math.trunc.

   int value = 100
   int8 small = int8(value)
   float ratio = float(value) / 3.0
   int rounded = math.round(ratio)
   print(small)
   print(rounded)

   output

   100
   33

5. 05

   Name resolution is monotonic.

   Reserved names are never reusable, visible names are never shadowable, and otherwise names may be reused in disjoint scopes. Adding code near an existing reference can never silently change what that reference means, for a person or for a model editing the file.

   int local_value()
       int x = 5
       return x
   
   int x = 7
   print(local_value() + x)

   output

   12

1. Semantic Compression 2nd of 10 score 77.52
2. LLM Learnability 10th of 10 score 71.97
3. Language Quality 4th of 10 score 66.13
4. Ecosystem 10th of 10 score 32.50
5. LLM Proficiency 10th of 10 score 4.91

Read the full results and how they were measured

• quidra-lang/quidra Core The compiler, native runtime, REPL, language server and standard namespaces. C++20 over LLVM, MIT licensed, released from immutable tags with archives for Linux, macOS and Windows.
• quidra-lang/playground Playground The compiler frontend compiled to WebAssembly and served as a static page. Check, format, lower to IR, inspect and patch in the browser; nothing leaves the tab.
• quidra-lang/vision Vision import vision. Image processing on rank-3 CHW tensors: crop, resize, flips and rotations, grayscale, threshold, blur, filter, dilate and erode. Invalid shapes or parameters return error and are never reinterpreted.
• quidra-lang/dnn DNN import dnn. Layers and optimizers as ordinary classes whose constructors can fail, plus activation and loss functions, over the neural autodiff foundation. The execution mode is chosen explicitly with dnn.mode.fast() or dnn.mode.deterministic().