Documentation Y# v8

Qu'est-ce que Y#

Y# (prononcé « why-sharp » ou « oyster ») est un langage compilé, statiquement typé, conçu pour le développement de jeux, l'IA/ML, le calcul haute performance et le serveur/web.

Caractéristiques V8

Print polymorphique, inférence Hindley-Milner, ECS first-class, Actor model, kernels GPU SPIR-V, tensor avec autodiff, package manager yo, et plusieurs backends de codegen (C, C++ Game, GPU).

Public visé

Ingénieurs systèmes, créateurs de jeux, chercheurs en ML, équipes produit exigeantes.

Via npm

Le moyen le plus rapide d'obtenir Y# sur n'importe quel système.

extrait
$ npm install ys-lang
$ oys --version
Y# v8.0.0 (Oyster Shell)

Windows

Un installateur officiel x64 v8.0 est disponible sur la page Téléchargements.

extrait
ys-v8.0.0-windows-x64-installer.exe

Vérifier l'installation

Une fois installé, la commande oys est disponible dans votre terminal.

extrait
$ oys build hello.ys
$ ./output.exe

Hello, world

Y# privilégie l'expression directe. Print et PrintLine acceptent tous les types.

extrait
Program Hello {
    Print("Bonjour, monde !");
}

Compilation & exécution

Compilez et lancez en une étape avec oys.

extrait
$ oys build hello.ys
$ ./output.exe
Bonjour, monde !

Exécution directe

Pour des scripts rapides, utilisez oys run.

extrait
$ oys run hello.ys

Déclarations

var pour les variables mutables, let pour immuables, const pour les constantes compile-time.

extrait
var x = 10;              // mutable, type inféré (Int)
var y: Float = 3.14;     // type explicite
let z = 42;              // immutable
const PI = 3.14159;      // constante

Types primitifs

Int (i64), Float (f64), Bool, String (UTF-8), Null, Void.

extrait
var n: Int = 42;
var f: Float = 3.14;
var b: Bool = true;
var s: String = "Y#";

Inférence Hindley-Milner

Le type checker propage l'information de type à travers toutes les expressions sans annotation explicite.

Conditionnels

Syntaxe C-like, parenthèses requises autour de la condition.

extrait
if (x > 0) {
    Print("positif");
} else if (x < 0) {
    Print("négatif");
} else {
    Print("zéro");
}

Boucle while

Boucle classique pilotée par une condition.

extrait
var i = 0;
while (i < 5) {
    PrintLine(i);
    i = i + 1;
}

Loop numérique

Loop est la boucle idiomatique de Y# — bornée, inclusive, incrément +1.

extrait
Loop(i from 1 to 10) {
    if (i % 2 == 0) {
        PrintLine(i);
    }
}

For (itérable)

Pour itérer sur une collection.

extrait
For(item in collection) {
    Print(item);
}

Définition

Le mot-clé Function démarre une fonction. Les types de paramètres et de retour sont explicites ou inférés.

extrait
Function Add(a: Int, b: Int) -> Int {
    Return a + b;
}

Function SayHello() {
    Print("Hello!");
}

Appel

Syntaxe d'appel classique.

extrait
var result = Add(3, 4);   // 7
SayHello();               // Hello!

Async & differentiable

Y# supporte les fonctions asynchrones et différentiables (pour l'autodiff GPU).

extrait
async Function FetchData(url: String) -> String {
    Return await HttpGet(url);
}

differentiable Function Loss(p: Float, t: Float) -> Float {
    Return (p - t) * (p - t);
}

Utilisation

Print et PrintLine acceptent Int, Float, Bool, String. Le compilateur dispatche vers le runtime C approprié.

extrait
Print(42);          // "42"
Print(3.14);        // "3.14"
Print("Hello");     // "Hello"
Print(true);        // "true"

PrintLine("done");  // "done\n"

Runtime

Les stubs C sont émis inline dans le code généré — pas de runtime à linker.

extrait
_ys_print_int(int64_t)
_ys_print_float(double)
_ys_print_str(const int8_t*)
_ys_print_newline()

Components

Un Component est un bloc de données pur.

extrait
Component Transform {
    x: Float,
    y: Float,
    z: Float,
    rotation: Float,
    scale: Float,
}

Entities

Une Entity agrège plusieurs Components.

extrait
Entity Player {
    Transform { x: 0, y: 0, z: 0, rotation: 0, scale: 1 }
    RigidBody { velocity: Vector3(0,0,0), mass: 1, drag: 0.1, useGravity: true }
    Mesh { path: "player.glb", material: "standard" }
}

Systems

Un System opère chaque frame sur toutes les entités correspondantes.

extrait
System Movement(Transform) {
    ForEach(Transform, Function(entity) {
        // logique par entité
    });
}

Définition

Un Actor encapsule de l'état et réagit à des messages.

extrait
Actor Counter {
    On(Increment) {
        State<Int> count;
        count = count + 1;
    }

    On(GetValue) {
        State<Int> count;
        Reply(count);
    }
}

// Usage:
Counter.Send(Increment);

Tensor

Type natif paramétré par sa forme.

extrait
var w: Tensor<Float, [3, 3]> = TensorRandom([3, 3]);

Operations standard

MatMul, Conv2d, Relu, Sigmoid, Softmax, MaxPool, BatchNorm — toutes compilées en kernels GPU optimisés.

Autodiff

Le préfixe differentiable génère automatiquement les gradients.

extrait
differentiable Function MatMul(a: Tensor, b: Tensor) -> Tensor {
    // compilé en SPIR-V 1.6 avec autodiff
}

oys — compilateur

La commande principale pour compiler, exécuter et tester.

extrait
$ oys build hello.ys              # produit ./output.exe
$ oys run hello.ys                # compile & exécute
$ oys test tests/                 # lance la suite de tests
$ oys new myproject               # nouveau projet

Options de build

Choisissez le backend cible.

extrait
$ oys build -t native game.ys     # exe natif
$ oys build -t gpu compute.ys     # SPIR-V
$ oys build -t game level.ys      # C++ ECS
$ oys build -t wasm app.ys        # WebAssembly

yo — package manager

Installation, suppression, publication.

extrait
$ yo install ecs
$ yo remove ecs
$ yo publish

std/core

io (Print, ReadLine, File I/O), math (Abs, Sin, Sqrt, Random), collections (List, Map, String).

std/ai

nn (Sequential, DenseLayer, ConvLayer, ModelTrain), tensor (TensorCreate, MatMul, MSE, Adam).

std/game

ecs (CreateEntity, Query, ForEach, Raycast), physics (Vec3, Quat, collisions).

std/server & std/web

http.Serve(port, handler), dom.QuerySelector, StateCreate/Get/Set/Watch.

Phases

Source .ys → Lexer (logos) → Parser (nom, AST 38 types) → Type Check (Hindley-Milner) → HIR (27 nœuds) → MIR (SSA, 14 instructions, 4 terminators) → MIR Opt (const fold, LICM, vectorize, reorder, inline) → Codegen.

Cibles

native/server/desktop/mobile (.exe via C/GCC), game (.ysg via C++), gpu (.spv SPIR-V 1.6), kernel (.o), wasm (.wasm).