@devaloop/devalang 0.0.1-alpha.1 → 0.0.1-alpha.10

package/docs/ROADMAP.md

@@ -6,7 +6,11 @@
 
 Devalang is a work in progress. Here’s what we’re planning next:
 
+## Completed
+
+- ✅ **Audio engine**: Integrate the audio engine for sound playback. 
 - ✅ **Basic syntax**: Implement the core syntax for Devalang, including data types and basic statements.
+- ✅ **Watch mode**: Add a watch mode to automatically rebuild on file changes.
 - ✅ **Module system**: Add support for importing and exporting variables between files using `@import` and `@export`.
 - ✅ **AST generation**: Implement the Abstract Syntax Tree (AST) generation for debugging and future compilation.
 - ✅ **Basic data types**: Support strings, numbers, booleans, maps, and arrays.
@@ -16,12 +20,11 @@ Devalang is a work in progress. Here’s what we’re planning next:
 - ✅ **Instruction calls**: Add support for instruction calls with parameters (e.g. `.kick auto {reverb:10, decay:20}`).
 - ✅ **Let assignments**: Implement `let` assignments for storing reusable values.
 - ✅ **Sample loading**: Add `@load` assignment to load samples (.mp3, .wav) for use as values.
+- ✅ **WASM support**: Compile Devalang to WebAssembly for use in web applications and other environments.
+- ✅ **VSCode extension**: Create a VSCode extension for syntax highlighting and code completion.
+
+## Upcoming
 
-- ⏳ **VSCode extension**: Create a VSCode extension for syntax highlighting and code completion.
-- ⏳ **WASM support**: Compile Devalang to WebAssembly for use in web applications.
-- ⏳ **Other statements**: Implement `if`, `else`, and other control structures.
-- ⏳ **Pattern and group statements**: Add support for `@pattern` and `@group` to organize code.
-- ⏳ **Watch mode**: Add a watch mode to automatically rebuild on file changes.
-- ⏳ **Functions**: Add support for defining and calling functions.
-- ⏳ **Audio engine**: Integrate the audio engine for sound playback.
+- ⏳ **Smart modules**: Let Devalang detect and use groups, samples, and variables without needing to import them manually.
+- ⏳ **Other statements**: Implement `pattern`, `function`, and other control structures.
 - ⏳ **Testing**: Expand test coverage for all features.

package/docs/SYNTAX.md

@@ -17,6 +17,18 @@ The engine uses indentation to define blocks, similar to Python. Each block must
 <details>
 <summary>Show available types</summary>
 
+### Duration
+
+Duration is defined using a number. It represents the length of a sound in milliseconds.
+
+```deva
+let duration = 1000
+```
+
+Will play a sound for 1000 milliseconds (1 second).
+
+NOTE: Other time units like seconds or beats are not supported yet, but will be in the future.
+
 ### String
 
 Strings are defined using double quotes.
@@ -46,7 +58,7 @@ let boolean = false
 Maps are key-value pairs defined using curly braces. Keys are strings, and values can be of any type (string, number, boolean, map, or array).
 
 ```deva
-let map = {myKey: 99}
+let map = { myKey: 99 }
 ```
 
 ### Array
@@ -81,13 +93,17 @@ bank 808
 
 Modules can be imported and exported to share variables between different files.
 
+> ⚠️ The import/export system is still experimental and may change in the future.
+>
+> You must explicitly declare imports and exports in each file — Devalang does not automatically detect or resolve them.
+
 Exporting variables from a module :
 
 ```deva
 # exported.deva
 
 let exportedIterator = 10
-let exportedParams = {drive: 50, decay: 30}
+let exportedParams = { drive: 50, decay: 30 }
 
 @export { exportedIterator, exportedParams }
 ```
@@ -103,22 +119,13 @@ loop exportedIterator:
     .kick auto exportedParams
 ```
 
-### Built-in triggers
-
-Usage : `.<trigger-name> <duration> <effects-map>`
+### Loading Samples
 
-Other triggers will be added in future releases (e.g. `.snare`, `.hihat`, `.tom`, `.clap`, `.crash`, `.ride`, `.synth`, `.bass`, `.pad`).
-You can also create custom triggers using the `@load` directive.
+You can load your own samples and use them in your music.
 
-```deva
-.kick
-.kick 1/4
-.kick auto {reverb: 50, decay: 30}
-```
+Load usage : `@load <path> as <name>`
 
-### Custom triggers
-
-Same usage as built-in triggers, but with custom audio files or effects.
+Trigger usage : `.<name> <duration> <params>`
 
 ```deva
 @load "./path/to/instrument.mp3" as mySample
@@ -126,7 +133,7 @@ Same usage as built-in triggers, but with custom audio files or effects.
 .mySample auto {reverb: 50, drive: 25}
 ```
 
-### Let variables
+### Variables
 
 Variables are defined using the `let` keyword, followed by the variable name and its value. The value can be of any type (string, number, boolean, map, or array).
 
@@ -134,11 +141,11 @@ Variables are defined using the `let` keyword, followed by the variable name and
 let number = 0
 let boolean = true
 let string = "string"
-let map = {myKey: 200}
+let map = { myKey: 200 }
 let array = [0, 1, 2]
 ```
 
-### Basic loops
+### Loops
 
 Loops are defined using the `loop` keyword, followed by the number of iterations. The body of the loop is indented.
 
@@ -146,3 +153,78 @@ Loops are defined using the `loop` keyword, followed by the number of iterations
 loop 10:
     # ...
 ```
+
+### Groups
+
+Groups are defined using the `group` keyword, followed by the group name. The body of the group is indented.
+
+Groups allow you to organize your code into reusable blocks. They can be called or spawned later in the code.
+
+```deva
+group myGroup:
+    # ...
+```
+
+### Conditions
+
+Conditions are defined using the `if` keyword, followed by a condition. The body of the condition is indented.
+
+```deva
+if myCondition:
+    # ...
+```
+
+You can also use `else` and `else if` for alternative branches:
+
+```deva
+if myCondition:
+    # ...
+else if anotherCondition:
+    # ...
+else:
+    # ...
+```
+
+### Calling Groups (Sequential Execution)
+
+Groups can be called using the `call` keyword, which executes only the group in sequence.
+
+> ⚠️ `call` only works on `group` declarations. It does not apply to other statements.
+
+This executes the entire group in the current execution thread, following a sequential order.
+
+```deva
+call myGroup
+```
+
+### Spawning Groups (Parallel Execution)
+
+Groups can be spawned using the `spawn` keyword, which executes only the group in parallel.
+
+> ⚠️ spawn also only works on group declarations. It does not make the group’s content parallel unless it explicitly uses spawn inside.
+
+This runs the entire group in a separate execution thread, allowing it to play alongside other actions.
+
+```deva
+spawn myGroup
+```
+
+### Synthesizers
+
+Synthesizers are defined using the `synth` keyword, followed by the synthesizer type. You can create a synthesizer instance and use it to play notes.
+
+```deva
+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 })
+
+# You can use call or spawn to execute the synthesizer actions in sequence or parallel.
+
+call mySynth
+```

package/docs/TODO.md

@@ -8,26 +8,29 @@ This is a list of tasks and features to be implemented in Devalang. Note that th
 
 ## Commands
 
-- [ ] New project
-- [ ] Template
-  - [ ] Implement template list
-  - [ ] Implement template info
+- [x] Init project
+  - [x] Implement init command
+  - [x] Implement template selector
+  - [ ] Implement project name validation
+- [x] Template
+  - [x] Implement template list
+  - [x] Implement template info
 - [x] Checking
-  - [ ] Implement watch mode
+  - [x] Implement watch mode
   - [ ] Implement debug mode
   - [ ] Implement compilation mode
 - [x] Building
-  - [ ] Implement watch mode
+  - [x] Implement watch mode
   - [ ] Implement debug mode
   - [ ] Implement compilation mode
   - [ ] Implement compression mode
-- [ ] Play
-  - [ ] Implement Audio Engine
-  - [ ] Implement loop mode
+- [x] Play
+  - [x] Implement Audio Engine
+  - [x] Implement loop mode
 
 ## Core components
 
-- [ ] Audio Engine
+- [x] Audio Engine
 - [x] Lexer
 - [x] Parser
 - [x] Preprocessor
@@ -36,31 +39,31 @@ This is a list of tasks and features to be implemented in Devalang. Note that th
 
 ## Syntax elements
 
-- [ ] #
+- [x] #
 - [x] @import
 - [x] @export
-- [ ] @group
-- [ ] @pattern
-- [ ] @function
 - [x] @load
 - [ ] @include
+- [ ] function
+- [ ] pattern
+- [x] group
+- [x] call
+- [x] spawn
+- [x] sleep
 - [x] bpm
 - [x] bank
 - [x] loop
 - [x] let
-- [ ] if
-- [ ] else
-- [ ] else if
+- [x] if
+- [x] else
+- [x] else if
 
-## Built-in triggers
+## Triggers
 
-- [x] .kick
-- [ ] .snare
-- [ ] .hihat
-- [ ] .tom
-- [ ] .clap
-- [ ] .crash
-- [ ] .ride
-- [ ] .synth
-- [ ] .bass
-- [ ] .pad
+- [x] Built-in triggers
+- [x] Custom triggers
+
+## Other TODOs
+
+- [ ] Comment all core components
+- [ ] Add unit tests for all core components

package/examples/condition.deva

@@ -0,0 +1,20 @@
+# This file demonstrates the use of conditional blocks in Devalang.
+
+@import { duration, default_bank, params, loopCount, tempo } from "./variables.deva"
+@import { myGroup } from "./group.deva"
+
+@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 auto
+    else if tempo > 155:
+        # Will be executed if the condition is false
+        .hatCustom auto
+    else:
+        .kickCustom auto
+        .hatCustom auto
+
+@export { conditionBlock }

package/examples/group.deva

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

package/examples/index.deva

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

package/examples/loop.deva

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

@@ -0,0 +1,9 @@
+# This file only exports variables for use in other files.
+
+let duration = auto
+let default_bank = 808
+let params = { decay: 10, delay: 30 }
+let loopCount = 5
+let tempo = 115
+
+@export { duration, default_bank, params, loopCount, tempo }

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.1",
+  "version": "0.0.1-alpha.10",
   "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": {
@@ -9,13 +9,14 @@
   },
   "scripts": {
     "prepublish": "cargo build --release && npm run script:postbuild",
-    "rust:dev": "cargo run",
     "rust:dev:build": "cargo run build --entry examples --output output",
     "rust:dev:check": "cargo run check --entry examples --output output",
+    "rust:wasm:web": "wasm-pack build --target=web --no-default-features",
+    "rust:wasm:node": "wasm-pack build --target=nodejs --no-default-features",
     "script:postbuild": "tsc && node out-tsc/scripts/postbuild.js",
     "script:version:bump": "tsc && node out-tsc/scripts/version/index.js"
   },
-  "homepage": "https://devaloop.com",
+  "homepage": "https://devalang.com",
   "keywords": [
     "devalang",
     "music",
@@ -40,4 +41,4 @@
   "dependencies": {
     "@types/node": "^24.0.3"
   }
-}
+}

package/project-version.json

@@ -1,6 +1,6 @@
 {
-  "version": "0.0.1-alpha.1",
+  "version": "0.0.1-alpha.10",
   "channel": "alpha",
-  "lastCommit": "",
-  "build": 1
+  "lastCommit": "a3649180a74374e193198131f4192a15f67009a5",
+  "build": 9
 }

package/rust/cli/build.rs

@@ -1,51 +1,137 @@
-use std::{ thread, time::Duration };
-
 use crate::{
+    config::Config,
     core::{
-        builder::{ build_ast, write_ast_to_file },
-        debugger::Debugger,
-        preprocessor::module::load_all_modules,
+        builder::Builder,
+        debugger::{
+            lexer::write_lexer_log_file,
+            preprocessor::write_preprocessor_log_file,
+            store::write_store_log_file,
+        },
+        preprocessor::loader::ModuleLoader,
+        store::global::GlobalStore,
+        utils::path::{ find_entry_file, normalize_path },
     },
-    runner::executer::execute_statements,
-    utils::{ loader::with_spinner, logger::log_message, path::{ find_entry_file, normalize_path } },
+    utils::{ logger::{ LogLevel, Logger }, spinner::with_spinner, watcher::watch_directory },
 };
+use std::{ thread, time::Duration };
+
+#[cfg(feature = "cli")]
+pub fn handle_build_command(
+    config: Option<Config>,
+    entry: Option<String>,
+    output: Option<String>,
+    watch: bool
+) {
+    let fetched_entry = if entry.is_none() {
+        config
+            .as_ref()
+            .and_then(|c| c.defaults.entry.clone())
+            .unwrap_or_else(|| "".to_string())
+    } else {
+        entry.clone().unwrap_or_else(|| "".to_string())
+    };
+
+    let fetched_output = if output.is_none() {
+        config
+            .as_ref()
+            .and_then(|c| c.defaults.output.clone())
+            .unwrap_or_else(|| "".to_string())
+    } else {
+        output.clone().unwrap_or_else(|| "".to_string())
+    };
+
+    let fetched_watch = if watch {
+        watch
+    } else {
+        config
+            .as_ref()
+            .and_then(|c| c.defaults.watch)
+            .unwrap_or(false)
+    };
+
+    let logger = Logger::new();
+
+    if fetched_entry.is_empty() {
+        logger.log_message(
+            LogLevel::Error,
+            "Entry path is not specified. Please provide a valid entry path."
+        );
+        std::process::exit(1);
+    }
+    if fetched_output.is_empty() {
+        logger.log_message(
+            LogLevel::Error,
+            "Output directory is not specified. Please provide a valid output directory."
+        );
+        std::process::exit(1);
+    }
 
-pub fn handle_build_command(entry: String, output: String) {
-    let entry_file = find_entry_file(&entry).unwrap_or_else(|| {
-        eprintln!("❌ index.deva not found in directory: {}", entry);
+    let entry_file = find_entry_file(&fetched_entry).unwrap_or_else(|| {
+        logger.log_message(
+            LogLevel::Error,
+            &format!("❌ index.deva not found in directory: {}", fetched_entry)
+        );
         std::process::exit(1);
     });
 
+    // SECTION Begin build
+    if fetched_watch {
+        begin_build(entry_file.clone(), fetched_output.clone());
+
+        logger.log_message(
+            LogLevel::Watcher,
+            &format!("Watching for changes in '{}'...", fetched_entry)
+        );
+
+        watch_directory(entry_file.clone(), move || {
+            logger.log_message(LogLevel::Watcher, "Detected changes, re-building...");
+
+            begin_build(entry_file.clone(), fetched_output.clone());
+        }).unwrap();
+    } else {
+        begin_build(entry_file.clone(), fetched_output.clone());
+    }
+}
+
+fn begin_build(entry: String, output: String) {
     let spinner = with_spinner("Building...", || {
         thread::sleep(Duration::from_millis(800));
     });
 
     let duration = std::time::Instant::now();
 
-    let normalized_entry_file = normalize_path(&entry_file);
+    let normalized_entry_file = normalize_path(&entry);
     let normalized_output_dir = normalize_path(&output);
 
-    let global_store = load_all_modules(&normalized_entry_file);
+    let mut global_store = GlobalStore::new();
+    let module_loader = ModuleLoader::new(&normalized_entry_file, &normalized_output_dir);
 
-    if let Some(module) = global_store.modules.get(&normalized_entry_file) {
-        let mut module_clone = module.clone();
+    // SECTION Load
+    // NOTE: We use modules in the build command, so we need to load them
+    let (modules_tokens, modules_statements) = module_loader.load_all_modules(&mut global_store);
 
-        let resolved_statements = execute_statements(&mut module_clone);
+    // SECTION Write logs
+    write_lexer_log_file(&normalized_output_dir, "lexer_tokens.log", modules_tokens.clone());
+    write_preprocessor_log_file(
+        &normalized_output_dir,
+        "resolved_statements.log",
+        modules_statements.clone()
+    );
+    write_store_log_file(&normalized_output_dir, "global_store.log", global_store.modules.clone());
 
-        let ast = build_ast(&resolved_statements);
+    // SECTION Building AST and Audio
+    let builder = Builder::new();
+    builder.build_ast(&modules_statements, &normalized_output_dir);
+    builder.build_audio(&modules_statements, &normalized_output_dir, &mut global_store);
 
-        let ast_dir = format!("{}/json", normalized_output_dir.clone());
-        write_ast_to_file(&ast, &ast_dir);
+    // SECTION Logging
+    let logger = Logger::new();
 
-        let debugger = Debugger::new(&module_clone);
-        let debug_dir = format!("{}/debug/", normalized_output_dir.clone());
-        debugger.write_files(debug_dir.as_str(), resolved_statements);
+    let success_message = format!(
+        "Build completed successfully in {:.2?}. Output files written to: '{}'",
+        duration.elapsed(),
+        normalized_output_dir
+    );
 
-        let success_message = format!(
-            "Build completed successfully in {:.2?}. Output files written to: '{}'",
-            duration.elapsed(),
-            normalized_output_dir
-        );
-        log_message(&success_message, "SUCCESS");
-    }
+    logger.log_message(LogLevel::Success, &success_message);
 }