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 auto value = values[]

iterate directly over values

Point(3.0, 4.0)

create a value and execute its class initialization

=

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 &: T & is a mutable reference, while T and const T are values. Const references are not part of the language. 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(NL)
   print(b[0])
   print(NL)
   
   int x = 1
   int &writer = &x
   // A const value is an independent snapshot, even when x has a writable alias.
   const int snapshot = x
   writer = 5
   print(snapshot)
   print(NL)

   output

   1
   9
   1

2. 02

   Authority is part of the call.

   A T & parameter explicitly receives writable caller-owned storage. By-value parameters do not grant access to mutate the caller's original binding. 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)
       print(NL)
   
   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. Initialization is tracked across branches, loops, references, fields and calls: definitely missing values fail at compile time, and uncertain reads are checked at runtime.

   int x
   print(x)
   print(NL)

   quidra check uninitialized.qui

   uninitialized.qui:2:7: error[UNINITIALIZED] 'x' is read before it is initialized on every path.
   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 name their destination type. Fixed-width narrowing is range checked; converting a non-integral real to an integer requires an explicit rounding operation such as math.round, math.floor, math.ceil or math.trunc.

   import math
   
   int value = 100
   int8 small = int8(value)
   real64 converted = real64(value)
   real64 ratio = converted / 3.0
   int rounded = math.round(ratio)
   print(small)
   print(NL)
   print(rounded)
   print(NL)

   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)
   print(NL)

   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 real compiler frontend runs as WebAssembly for browser-local Check, Format, IR, Inspect and Patch. Native Build/Run use a sandboxed runner only when requested, gated to the same language version and exact Core commit.
• quidra-lang/math Math import math. Generic mathematical semantics such as reductions, unary functions, dot products and matrix multiplication live outside Core with their own native and compiler optimizations.
• quidra-lang/nn NN import nn. Architecture-independent neural-network state, reusable layers, losses, optimizers, persistence and NN-owned accelerator/compiler policy live here.
• quidra-lang/vision Vision import vision. Image codecs and tensor image processing such as crop, resize, grayscale, filtering and morphology are Vision-owned package semantics.
• quidra-lang/video Video import video. Video decoding and FFmpeg integration are package-owned; decoded frames are ordinary Quidra tensors and device transfer remains explicit.
• quidra-lang/dnn DNN import dnn. Concrete model architecture families such as AlexNet, VGG and ResNet compose NN and Math rather than re-owning generic layers, optimizers or accelerator backends.