@devaloop/devalang 0.0.1-alpha.8 → 0.0.1-alpha.9

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "devalang"
-version = "0.0.1-alpha.8"
+version = "0.0.1-alpha.9"
 authors = ["Devaloop <contact@devaloop.com>"]
 description = "Write music like code. Devalang is a domain-specific language (DSL) for sound designers and music hackers. Compose, automate, and control sound — in plain text."
 license = "MIT"

package/README.md

@@ -27,12 +27,12 @@ Compose loops, control samples, render and play audio — all in clean, readable
 
 From studio sketches to live sets, Devalang gives you rhythmic control — with the elegance of code.
 
-> 🚧 **v0.0.1-alpha.8 Notice** 🚧
+> 🚧 **v0.0.1-alpha.9 Notice** 🚧
 >
 > NEW: Devalang VSCode extension is now available !
 > [Get it here](https://marketplace.visualstudio.com/items?itemName=devaloop.devalang-vscode).
 >
-> NEW: Devalang supports conditional statements (`if`, `else`, `else if`) for more dynamic compositions !
+> Includes synthesis, playback, and rendering features, but is still in early development.
 >
 > Currently, Devalang CLI is only available for **Windows**.  
 > Linux and macOS binaries will be added in future releases via cross-platform builds.
@@ -181,24 +181,20 @@ bpm globalBpm
 bank globalBank
 # Will declare a custom instrument bank using the globalBank variable
 
-# Loops
-
 loop 5:
     .customKick kickDuration {reverb=50, drive=25}
     # Will play 5 times a custom sample for 500ms with reverb and overdrive effects
 
-# Groups
-
 group myGroup:
     .customKick kickDuration {reverb=50, drive=25}
     # Will play the same sample in a group, allowing for more complex patterns
 
-# Will be executed line by line (sequentially)
 call myGroup
+# Will be executed line by line (sequentially)
 
+# spawn myGroup
 # Will be executed in parallel (concurrently)
 # ⚠️ Note: `spawn` runs the entire group in parallel, but the group’s internal logic remains sequential unless it uses `spawn` internally.
-# spawn myGroup
 ```
 
 > 🧠 Note: `call` and `spawn` only work with `group` blocks. They do not apply to individual samples or other statements.

package/docs/CHANGELOG.md

@@ -4,6 +4,33 @@
 
 # Changelog
 
+## Version 0.0.1-alpha.9 (2025-07-14)
+
+### ✨ Syntax
+
+- Added support for `synth` directives to define synthesizer sounds directly in code  
+  → Example:
+
+  ```deva
+  let mySynth = synth sine
+  ```
+
+### 🧠 Core Engine
+
+- ✅ **Major refactor** of the resolution layer:
+
+  - `condition`, `loop`, `group`, `trigger`, `call`, `spawn`, and `driver` were fully rewritten
+  - Ensures **correct variable scoping**, **cross-module references**, and **imported symbol resolution**
+
+- ✅ Audio interpreter updated:
+  - `call` and `spawn` now execute correctly in parallel, preserving **temporal alignment** across groups
+
+### 🧩 Language Features
+
+- Improved `@import` behavior:
+  - Modules can now be imported using **relative paths only**
+  - No need for absolute or root-based imports
+
 ## Version 0.0.1-alpha.8 (2025-07-12)
 
 ### Syntax

package/examples/condition.deva

@@ -1,24 +1,20 @@
 # This file demonstrates the use of conditional blocks in Devalang.
 
-@import { myGroup } from "./examples/group.deva"
+@import { duration, default_bank, params, loopCount, tempo } from "./variables.deva"
+@import { myGroup } from "./group.deva"
 
-@load "./examples/samples/kick-808.wav" as kickCustom
-@load "./examples/samples/hat-808.wav" as hatCustom
+@load "./samples/kick-808.wav" as kickCustom
+@load "./samples/hat-808.wav" as hatCustom
 
 group conditionBlock:
     if tempo > 120:
         # Will be executed if the condition is true
-        .kickCustom
+        .kickCustom auto
     else if tempo > 155:
         # Will be executed if the condition is false
-        .hatCustom
+        .hatCustom auto
     else:
-        # Following lines will be executed if the condition is neither true or false
-        
-        # This will call myGroup sequentially (in the main thread)
-        call myGroup
-
-        # This will spawn a group in parallel to the main thread (kick + hat simultaneously)
-        # spawn myGroup
+        .kickCustom auto
+        .hatCustom auto
 
 @export { conditionBlock }

package/examples/group.deva

@@ -1,9 +1,9 @@
 # This file demonstrates the use of grouping in Devalang.
 
-@import { duration, default_bank, params, loopCount, tempo } from "./examples/variables.deva"
+@import { duration, default_bank, params, loopCount, tempo } from "./variables.deva"
 
-@load "./examples/samples/kick-808.wav" as kickCustom
-@load "./examples/samples/hat-808.wav" as hatCustom
+@load "./samples/kick-808.wav" as kickCustom
+@load "./samples/hat-808.wav" as hatCustom
 
 group myGroup:
     .kickCustom duration params

package/examples/index.deva

@@ -1,16 +1,18 @@
 # This file demonstrates the use of main features in Devalang.
 
-@import { duration, default_bank, params, loopCount, tempo } from "./examples/variables.deva"
-@import { conditionBlock } from "./examples/condition.deva"
-@import { myGroup } from "./examples/group.deva"
+@import { duration, default_bank, params, loopCount, tempo } from "./variables.deva"
+@import { myLead } from "./synth.deva"
+@import { myLoop } from "./loop.deva"
 
-
-@load "./examples/samples/kick-808.wav" as kickCustom
-@load "./examples/samples/hat-808.wav" as hatCustom
+@load "./samples/kick-808.wav" as kickCustom
+@load "./samples/hat-808.wav" as hatCustom
 
 bpm tempo
 
 bank default_bank
 
-# This will call the group sequentially (line by line)
-call conditionBlock
+group myTrack:
+    spawn myLoop
+    spawn myLead
+
+call myTrack

package/examples/loop.deva

@@ -1,15 +1,17 @@
 # This file demonstrates the use of a loop in Devalang.
 
-@import { duration, default_bank, params, loopCount, tempo } from "./examples/variables.deva"
+@import { duration, default_bank, params, loopCount, tempo } from "./variables.deva"
 
-@load "./examples/samples/kick-808.wav" as kickCustom
-@load "./examples/samples/hat-808.wav" as hatCustom
+@load "./samples/kick-808.wav" as kickCustom
+@load "./samples/hat-808.wav" as hatCustom
 
-loop loopCount:
-    .kickCustom duration params
+group myLoop:
+    loop loopCount:
+        .kickCustom duration params
 
-    # Uncomment the next line (.hat) while executing "play" command
-    # with `--repeat` option to see magic happen !
+        # Uncomment the next line (.hat) while executing "play" command
+        # with `--repeat` option to see magic happen !
 
-    .hatCustom duration params
+        .hatCustom duration params
 
+@export { myLoop }

package/examples/synth.deva

@@ -0,0 +1,14 @@
+# This file defines a simple synth lead using Devalang's syntax.
+
+group myLead:
+    let mySynth = synth sine
+    
+    mySynth -> note(C4, { duration: 400 })
+    mySynth -> note(G4, { duration: 400 })
+    mySynth -> note(E4, { duration: 600 })
+    mySynth -> note(A4, { duration: 400 })
+    mySynth -> note(F4, { duration: 800 })
+    mySynth -> note(D4, { duration: 400 })
+    mySynth -> note(B3, { duration: 600 })
+
+@export { myLead }

package/examples/variables.deva

@@ -2,7 +2,7 @@
 
 let duration = auto
 let default_bank = 808
-let params = {decay:10, delay:30}
+let params = { decay: 10, delay: 30 }
 let loopCount = 5
 let tempo = 115
 

package/out-tsc/scripts/version/fetch.js

@@ -16,19 +16,15 @@ exports.fetchVersion = void 0;
 const fs_1 = __importDefault(require("fs"));
 const child_process_1 = require("child_process");
 const fetchVersion = (projectVersionPath) => __awaiter(void 0, void 0, void 0, function* () {
-    // Lire le fichier
     const data = JSON.parse(fs_1.default.readFileSync(projectVersionPath, "utf-8"));
-    // Incrémenter le numéro de build
     data.build = (data.build || 0) + 1;
-    // Récupérer le dernier hash git
     try {
         const commit = (0, child_process_1.execSync)("git rev-parse HEAD").toString().trim();
         data.lastCommit = commit;
     }
     catch (err) {
-        console.warn("⚠️ Impossible de récupérer le hash git.");
+        console.warn("⚠️ Unable to fetch git commit hash. Ensure you are in a git repository.");
     }
-    // Écrire la mise à jour
     fs_1.default.writeFileSync(projectVersionPath, JSON.stringify(data, null, 2));
 });
 exports.fetchVersion = fetchVersion;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@devaloop/devalang",
   "private": false,
-  "version": "0.0.1-alpha.8",
+  "version": "0.0.1-alpha.9",
   "description": "Write music like code. Devalang is a domain-specific language (DSL) for sound designers and music hackers. Compose, automate, and control sound — in plain text.",
   "main": "out-tsc/index.js",
   "bin": {

package/project-version.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.0.1-alpha.8",
+  "version": "0.0.1-alpha.9",
   "channel": "alpha",
-  "lastCommit": "fdb440173acc82227067864903aabc83e1d1570c",
-  "build": 7
+  "lastCommit": "61ab816a54275f2617ffd4327eb388ed822c36eb",
+  "build": 8
 }

package/rust/core/audio/engine.rs

@@ -2,7 +2,10 @@ use std::{ collections::HashMap, fs::File, io::BufReader };
 use hound::{ SampleFormat, WavSpec, WavWriter };
 use rodio::{ Decoder, Source };
 
-use crate::core::{ store::variable::VariableTable, utils::path::normalize_path };
+use crate::core::{
+    store::variable::VariableTable,
+    utils::path::{ normalize_path, resolve_relative_path },
+};
 
 const SAMPLE_RATE: u32 = 44100;
 const CHANNELS: u16 = 2;
@@ -12,14 +15,16 @@ pub struct AudioEngine {
     pub volume: f32,
     pub variables: VariableTable,
     pub buffer: Vec<i16>,
+    pub module_name: String,
 }
 
 impl AudioEngine {
-    pub fn new() -> Self {
+    pub fn new(module_name: String) -> Self {
         AudioEngine {
             volume: 1.0,
             buffer: vec![],
             variables: VariableTable::new(),
+            module_name,
         }
     }
 
@@ -32,14 +37,28 @@ impl AudioEngine {
         }
     }
 
-    pub fn set_duration(&mut self, duration_secs: f32) {
-        let mut total_samples = (duration_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
+    pub fn merge_with(&mut self, other: AudioEngine) {
+        if other.buffer.iter().all(|&s| s == 0) {
+            eprintln!("⚠️ Skipping merge: other buffer is silent");
+            return;
+        }
 
-        if total_samples % (CHANNELS as usize) != 0 {
-            total_samples += 1;
+        if self.buffer.iter().all(|&s| s == 0) {
+            self.buffer = other.buffer;
+            self.variables.variables.extend(other.variables.variables);
+            return;
         }
 
-        self.buffer.resize(total_samples, 0);
+        self.mix(&other);
+        self.variables.variables.extend(other.variables.variables);
+    }
+
+    pub fn set_duration(&mut self, duration_secs: f32) {
+        let total_samples = (duration_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
+
+        if self.buffer.len() < total_samples {
+            self.buffer.resize(total_samples, 0);
+        }
     }
 
     pub fn set_variables(&mut self, variables: VariableTable) {
@@ -72,18 +91,76 @@ impl AudioEngine {
         Ok(())
     }
 
-    pub fn insert(
+    pub fn insert_note(
+        &mut self,
+        waveform: String,
+        freq: f32,
+        amp: f32,
+        start_time_ms: f32,
+        duration_ms: f32
+    ) {
+        let sample_rate = SAMPLE_RATE as f32;
+        let channels = CHANNELS as usize;
+
+        let total_samples = ((duration_ms / 1000.0) * sample_rate) as usize;
+        let start_sample = ((start_time_ms / 1000.0) * sample_rate) as usize;
+        let amplitude = (i16::MAX as f32) * amp.clamp(0.0, 1.0);
+
+        let mut samples = Vec::with_capacity(total_samples);
+        let fade_len = (sample_rate * 0.01) as usize; // 10 ms fade
+
+        for i in 0..total_samples {
+            let t = ((start_sample + i) as f32) / sample_rate;
+            let phase = 2.0 * std::f32::consts::PI * freq * t;
+
+            let mut value = match waveform.as_str() {
+                "sine" => phase.sin(),
+                "square" => if phase.sin() >= 0.0 { 1.0 } else { -1.0 }
+                "saw" => 2.0 * (freq * t - (freq * t + 0.5).floor()),
+                "triangle" => (2.0 * (2.0 * (freq * t).fract() - 1.0)).abs() * 2.0 - 1.0,
+                _ => 0.0,
+            };
+
+            // Fade in/out
+            if i < fade_len {
+                value *= (i as f32) / (fade_len as f32);
+            } else if i >= total_samples - fade_len {
+                value *= ((total_samples - i) as f32) / (fade_len as f32);
+            }
+
+            samples.push((value * amplitude) as i16);
+        }
+
+        // Convert to stereo
+        let stereo_samples: Vec<i16> = samples
+            .iter()
+            .flat_map(|s| vec![*s, *s])
+            .collect();
+
+        let offset = start_sample * channels;
+        let required_len = offset + stereo_samples.len();
+
+        if self.buffer.len() < required_len {
+            self.buffer.resize(required_len, 0);
+        }
+
+        for (i, sample) in stereo_samples.iter().enumerate() {
+            if *sample != 0 {
+            }
+            self.buffer[offset + i] = self.buffer[offset + i].saturating_add(*sample);
+        }
+    }
+
+    pub fn insert_sample(
         &mut self,
         filepath: &str,
         time_secs: f32,
         dur_sec: f32,
         effects: Option<HashMap<String, f32>>
     ) {
-        let normalized_filepath = normalize_path(filepath);
+        let resolved = resolve_relative_path(&self.module_name.clone(), filepath);
 
-        let file = BufReader::new(
-            File::open(normalized_filepath).expect("Failed to open audio file")
-        );
+        let file = BufReader::new(File::open(resolved).expect("Failed to open audio file"));
         let decoder = Decoder::new(file).expect("Failed to decode audio file");
 
         // Mono or stereo reading possible here, we will duplicate in L/R

package/rust/core/audio/interpreter/arrow_call.rs

@@ -0,0 +1,129 @@
+use crate::core::{
+    audio::engine::AudioEngine,
+    parser::statement::{ Statement, StatementKind },
+    shared::value::Value,
+    store::variable::VariableTable,
+};
+
+use std::collections::HashMap;
+
+pub fn interprete_call_arrow_statement(
+    stmt: &Statement,
+    audio_engine: &mut AudioEngine,
+    variable_table: &VariableTable,
+    base_bpm: f32,
+    base_duration: f32,
+    max_end_time: &mut f32,
+    mut cursor_time: Option<&mut f32>,
+    update_cursor: bool
+) -> (f32, f32) {
+    let cursor_copy = cursor_time
+        .as_ref()
+        .map(|c| **c)
+        .unwrap_or(0.0);
+
+    if let StatementKind::ArrowCall { target, method, args } = &stmt.kind {
+        let Some(Value::Map(synth_map)) = variable_table.get(target) else {
+            println!("❌ Synth '{}' not found in variable table", target);
+            return (*max_end_time, cursor_copy);
+        };
+
+        let Some(Value::String(entity)) = synth_map.get("entity") else {
+            println!("❌ Missing 'entity' key in synth '{}'.", target);
+            return (*max_end_time, cursor_copy);
+        };
+
+        if entity != "synth" {
+            println!("❌ '{}' is not a synth, entity is '{}'.", target, entity);
+            return (*max_end_time, cursor_copy);
+        }
+
+        let Some(Value::Map(value_map)) = synth_map.get("value") else {
+            println!("❌ Missing 'value' map in synth '{}'.", target);
+            return (*max_end_time, cursor_copy);
+        };
+
+        let Some(Value::String(waveform)) = value_map.get("waveform") else {
+            println!("❌ Missing or invalid 'waveform' in synth '{}'.", target);
+            return (*max_end_time, cursor_copy);
+        };
+
+        let Some(Value::Map(params)) = value_map.get("parameters") else {
+            println!("❌ Missing or invalid 'parameters' in synth '{}'.", target);
+            return (*max_end_time, cursor_copy);
+        };
+
+        let freq = extract_f32(params, "freq").unwrap_or(440.0);
+        let amp = extract_f32(params, "amp").unwrap_or(1.0);
+
+        if method == "note" {
+            let Some(Value::Identifier(note_name)) = args.get(0) else {
+                println!("❌ Invalid or missing argument for 'note' method on '{}'.", target);
+                return (*max_end_time, cursor_copy);
+            };
+
+            let mut final_note_params = HashMap::new();
+            if let Some(Value::Map(note_params)) = args.get(1) {
+                for (key, value) in note_params {
+                    final_note_params.insert(key.clone(), value.clone());
+                }
+            }
+
+            let duration_ms = extract_f32(&final_note_params, "duration").unwrap_or(base_duration);
+            let duration_secs = duration_ms / 1000.0;
+
+            let final_freq = note_to_freq(note_name);
+            let start_time = cursor_copy;
+            let end_time = start_time + duration_secs;
+
+            audio_engine.insert_note(
+                waveform.clone(),
+                final_freq,
+                amp,
+                start_time * 1000.0,
+                duration_ms
+            );
+
+            *max_end_time = (*max_end_time).max(end_time);
+
+            if update_cursor {
+                if let Some(c) = cursor_time.as_mut() {
+                    **c = end_time;
+                }
+            }
+
+            return (*max_end_time, end_time);
+        } else {
+            println!("❌ Unknown method '{}' on synth '{}'.", method, target);
+        }
+    }
+
+    (*max_end_time, cursor_copy)
+}
+
+fn extract_f32(map: &HashMap<String, Value>, key: &str) -> Option<f32> {
+    map.get(key).and_then(|v| {
+        match v {
+            Value::Number(n) => Some(*n),
+            _ => None,
+        }
+    })
+}
+
+fn note_to_freq(note: &str) -> f32 {
+    let notes = vec!["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
+
+    if note.len() < 2 || note.len() > 3 {
+        return 440.0;
+    }
+
+    let (name, octave_str) = note.split_at(note.len() - 1);
+    let semitone = notes
+        .iter()
+        .position(|&n| n == name)
+        .unwrap_or(9) as i32;
+    let octave = octave_str.parse::<i32>().unwrap_or(4);
+    let midi_note = (octave + 1) * 12 + semitone;
+
+    440.0 * (2.0_f32).powf(((midi_note as f32) - 69.0) / 12.0)
+}

package/rust/core/audio/interpreter/call.rs

@@ -14,8 +14,30 @@ pub fn interprete_call_statement(
     max_end_time: f32,
     cursor_time: f32
 ) -> (AudioEngine, f32, f32) {
-    if let Value::String(identifier) = &stmt.value {
-        if let Some(Value::Map(map)) = variable_table.clone().get(identifier) {
+    match &stmt.value {
+        Value::String(identifier) | Value::Identifier(identifier) => {
+            if let Some(Value::Map(map)) = variable_table.clone().get(identifier) {
+                if let Some(Value::Block(block)) = map.get("body") {
+                    let (eng, _, end_time) = execute_audio_block(
+                        audio_engine,
+                        variable_table,
+                        block.clone(),
+                        base_bpm,
+                        base_duration,
+                        max_end_time,
+                        cursor_time
+                    );
+
+                    return (eng, max_end_time.max(end_time), end_time);
+                } else {
+                    eprintln!("❌ Group '{}' has no 'body' block", identifier);
+                }
+            } else {
+                eprintln!("❌ Group '{}' not found or not a map", identifier);
+            }
+        }
+
+        Value::Map(map) => {
             if let Some(Value::Block(block)) = map.get("body") {
                 let (eng, _, end_time) = execute_audio_block(
                     audio_engine,
@@ -29,13 +51,13 @@ pub fn interprete_call_statement(
 
                 return (eng, max_end_time.max(end_time), end_time);
             } else {
-                eprintln!("❌ 'body' must be a block");
+                eprintln!("❌ Call map has no 'body' block");
             }
-        } else {
-            eprintln!("❌ Call target '{}' not found or invalid", identifier);
         }
-    } else {
-        eprintln!("❌ Invalid call statement: expected string identifier");
+
+        other => {
+            eprintln!("❌ Invalid call statement: expected identifier or map, found {:?}", other);
+        }
     }
 
     (audio_engine, max_end_time, cursor_time)

package/rust/core/audio/interpreter/condition.rs

@@ -1,5 +1,9 @@
 use crate::core::{
-    audio::{ engine::AudioEngine, evaluator::evaluate_condition_string, interpreter::driver::execute_audio_block },
+    audio::{
+        engine::AudioEngine,
+        evaluator::evaluate_condition_string,
+        interpreter::driver::execute_audio_block,
+    },
     parser::statement::Statement,
     shared::value::Value,
     store::variable::VariableTable,