Added:

- `build.steps` for pre-build generators (e.g., `moc`/`uic`/`rcc`)
- `build.pkg_config` for `pkg-config`-driven cflags/ldflags resolution
- `[toolchain]` support for `uic`, `moc`, `rcc`
- Step command variables (`{uic}`, `{moc}`, `{rcc}`, `{cflags}`, `{stem}`, `{in}`, `{out}`)
- `{profile}` placeholder support for dependency paths

AGENT.md

@@ -0,0 +1,126 @@
+# AGENT.md
+
+## Project Overview
+
+**DCR (Dexoron Cargo Realization)** — CLI-утилита для управления C/C++/ASM проектами в стиле Cargo.
+
+- **Язык реализации**: Rust (edition 2024)
+- **Лицензия**: MIT
+- **Репозиторий**: [github.com/dexoron/dcr](https://github.com/dexoron/dcr)
+
+## Architecture
+
+### Source Tree (`src/`)
+
+```
+src/
+├── main.rs          # Точка входа, маршрутизация CLI-команд
+├── config.rs        # Глобальные константы: профили сборки, шаблон main.c
+├── cli/             # Реализация CLI-команд
+│   ├── new.rs       # dcr new <name>
+│   ├── init.rs      # dcr init
+│   ├── build.rs     # dcr build [--debug|--release]
+│   ├── run.rs       # dcr run [--debug|--release]
+│   ├── clean.rs     # dcr clean [--all]
+│   ├── help.rs      # dcr --help
+│   └── flag_update.rs  # dcr --update (self-update через GitHub Releases)
+├── core/            # Бизнес-логика
+│   ├── config.rs    # Парсинг/валидация/форматирование dcr.toml (struct Config)
+│   ├── deps.rs      # Разрешение path-зависимостей, генерация dcr.lock
+│   ├── runner.rs    # Запуск скомпилированного бинарника
+│   ├── workspace.rs # Поддержка [workspace] и упорядочивание сборки
+│   └── builder/     # Бэкенды компиляторов/ассемблеров
+│       ├── mod.rs   # Общий интерфейс сборки
+│       ├── gcc.rs   # GCC backend
+│       ├── clang.rs # Clang backend
+│       ├── msvc.rs  # MSVC backend
+│       ├── nasm.rs  # NASM backend (ASM)
+│       └── gas.rs   # GAS backend (ASM)
+├── platform/        # Платформенно-зависимая логика
+│   ├── mod.rs       # Общий интерфейс платформ
+│   ├── linux.rs
+│   ├── macos.rs
+│   └── windows.rs
+└── utils/           # Вспомогательные утилиты
+    ├── fs.rs        # Работа с файловой системой
+    ├── log.rs       # Логирование (error, warn)
+    └── text.rs      # Форматирование текста / цвета
+```
+
+### Key Concepts
+
+- **`dcr.toml`** — конфигурационный файл проекта (аналог `Cargo.toml`). Секции: `[package]`, `[build]`, `[toolchain]`, `[dependencies]`, `[workspace]`.
+- **Профили сборки**: `debug` (по умолчанию) и `release`. Встроенные флаги зависят от компилятора. Пользовательские флаги через `build.cflags` / `build.ldflags`.
+- **Инкрементальная сборка**: объектные файлы кешируются по mtime. Отслеживание заголовков пока не реализовано (см. `TODO.md`).
+- **Workspace**: корневой `dcr.toml` с секцией `[workspace]` описывает member-проекты и их зависимости; сборка происходит в топологическом порядке.
+- **Path dependencies**: зависимости по путям автоматически добавляют include/lib-пути; генерируется `dcr.lock`.
+- **Build kinds**: `bin` (бинарник), `staticlib` (`.a`), `sharedlib` (`.so`/`.dylib`/`.dll`).
+
+## Supported Platforms
+
+| Platform | Target triple |
+|---|---|
+| Linux | `x86_64-unknown-linux-gnu` |
+| macOS Intel | `x86_64-apple-darwin` |
+| macOS ARM | `aarch64-apple-darwin` |
+| Windows | `x86_64-pc-windows-msvc` |
+
+## Dependencies (Cargo)
+
+| Crate | Purpose |
+|---|---|
+| `reqwest` | HTTP-запросы для `--update` (blocking, rustls-tls) |
+| `serde` | Сериализация/десериализация |
+| `toml` | Парсинг `dcr.toml` |
+| `sha2` | Хеширование при обновлении |
+| `self-replace` | Замена бинарника при `--update` |
+
+## Development
+
+### Build & Run
+
+```bash
+cargo build             # debug build
+cargo build --release   # release build
+cargo run -- new hello  # создать проект "hello"
+```
+
+### Code Quality
+
+```bash
+cargo fmt --all
+cargo clippy --all-targets --all-features -- -D warnings
+cargo check
+cargo test
+```
+
+### CI/CD
+
+- **CI**: `.github/workflows/ci.yml` — проверки при PR/push
+- **Release**: `.github/workflows/release.yml` — сборка бинарников при пуше тега `v*`
+
+### Tests
+
+- Интеграционные CLI-тесты: `tests/cli_basic.rs`
+
+## Code Conventions
+
+- Rust stable edition 2024
+- Форматирование: `cargo fmt`
+- Линтинг: `cargo clippy` без warnings
+- Функции — маленькие и сфокусированные
+- Имена — понятные и описательные
+- Пользовательские сообщения CLI — на английском языке
+- Вывод ошибок/предупреждений через `utils::log::{error, warn}`
+
+## TODO
+
+- В файле `TODO.md`
+
+## Useful Links
+
+- Документация проекта: `docs/`
+- Changelog: `CHANGELOG.md`
+- Contributing: `CONTRIBUTING.md`
+- FAQ: `FAQ.md`
+- Установка: `install.sh` (Linux/macOS), `install.ps1` (Windows)

CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## [0.2.10] - 2026-03-16
+Added:
+- `build.steps` for pre-build generators (e.g., `moc`/`uic`/`rcc`)
+- `build.pkg_config` for `pkg-config`-driven cflags/ldflags resolution
+- `[toolchain]` support for `uic`, `moc`, `rcc`
+- Step command variables (`{uic}`, `{moc}`, `{rcc}`, `{cflags}`, `{stem}`, `{in}`, `{out}`)
+- `{profile}` placeholder support for dependency paths
+
+## [0.2.9] - 2026-03-14
+Added:
+- Header dependency tracking for fine-grained incremental builds (rebuilds when `#include` files change)
+- Complete internal rewrite of the builder module: merged duplicate compilation backends
+
+Changed:
+- `cflags` and `default_flags` no longer incorrectly leak to the linker stage in GCC/Clang
+- Reduced builder codebase size by over 20% while increasing reliability
+- Greatly expanded test suite with 34 new tests covering configuration, CLI errors, and path operations
+
+## [0.2.8] - 2026-03-06
+Added:
+- Workspace support (`[workspace]` with deps ordering)
+- `clean --all` for workspace members
+Changed:
+- Project root discovery for `build/run/clean` (searches parent dirs)
+- Workspace paths are excluded from root source scan
+- Build output now uses a Cargo-style `Compiling <name> v<version>` line
+- Build time now reports total time for the whole build stage (workspace included)
+- Cache hits are silent (no compile line when nothing is rebuilt)
+- Safer build cache: fingerprints include headers and resolved library files
+
+## [0.2.7] - 2026-03-03
+Added:
+- Toolchain overrides via `[toolchain]` and env (`DCR_*`)
+- ASM `.S` preprocessing via GCC/Clang (`-x assembler-with-cpp`)
+
+## [0.2.6] - 2026-03-01
+Added:
+- `sharedlib` build kind (shared library output)
+- ASM projects (`build.language = "asm"`)
+- NASM and GAS backends
+- `build.platform` architecture hint for `-march` / `/arch`
+- Basic CLI integration tests
+
 ## [0.2.5] - 2026-02-26
 Added:
 - Incremental builds (object caching by mtime)

CONTRIBUTING.md

@@ -30,6 +30,7 @@ Before PR, run:
 cargo fmt --all
 cargo clippy --all-targets --all-features -- -D warnings
 cargo check
+cargo test
 ```
 
 ## CI/CD and Releases

Cargo.lock

@@ -90,8 +90,9 @@ dependencies = [
 
 [[package]]
 name = "dcr"
-version = "0.2.4"
+version = "0.2.10"
 dependencies = [
+ "glob",
  "reqwest",
  "self-replace",
  "serde",
@@ -262,6 +263,12 @@ dependencies = [
  "wasip3",
 ]
 
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
 [[package]]
 name = "hashbrown"
 version = "0.15.5"

Cargo.toml

@@ -1,10 +1,11 @@
 [package]
 name = "dcr"
-version = "0.2.4"
+version = "0.2.10"
 edition = "2024"
 build = "build.rs"
 
 [dependencies]
+glob = "0.3"
 reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "rustls-tls"] }
 serde = { version = "1", features = ["derive"] }
 self-replace = "1"

README.md

@@ -15,6 +15,8 @@ The current implementation is written in Rust.
 - Run the compiled binary
 - Clean build artifacts
 - Generate a minimal C project template
+- Build static and shared libraries
+- ASM projects with NASM/GAS or via GCC/Clang
 - Update the binary via `dcr --update` (GitHub Releases, not for pacman/AUR installs)
 
 ## Supported Platforms
@@ -111,6 +113,7 @@ Run manually:
 
 ### `dcr clean`
 Removes the `target` directory in the project root.
+Use `dcr clean --all` in a workspace root to clean all member projects.
 
 ## Build Profiles
 Two profiles are supported:
@@ -119,8 +122,10 @@ Two profiles are supported:
 
 Custom flags can be added in `dcr.toml` via `build.cflags` and `build.ldflags`.
 You can also set `build.target` to override the output directory (profile-independent).
+You can set `build.platform` to pass `-march=<platform>` (GCC/Clang) or `/arch:*` (MSVC) where supported.
 Use `build.kind = "staticlib"` to build a static library instead of a binary.
-`dcr run` is only for `build.kind = "bin"` and will fail for `staticlib`.
+Use `build.kind = "sharedlib"` to build a shared library (`.so`/`.dylib`/`.dll`).
+`dcr run` is only for `build.kind = "bin"` and will fail for libraries.
 
 ## Configuration
 The main project file is `dcr.toml`.
@@ -136,13 +141,32 @@ version = "0.1.0"
 language = "c"
 standard = "c11"
 compiler = "clang"
+# Optional platform hint
+# platform = "x86_64"
 # Optional custom flags
 cflags = ["-Wall", "-Wextra"]
 ldflags = ["-lm"]
 
+[toolchain]
+# Optional tool overrides:
+# cc = "clang"
+# cxx = "clang++"
+# as = "as"
+# ar = "ar"
+# ld = "ld"
+
 [dependencies]
 ```
 
+Workspace example:
+
+```toml
+[workspace]
+kernel = { path = "src/kernel", deps = ["core", "userspace"] }
+core = { path = "src/core", deps = ["userspace"] }
+userspace = { path = "src/userspace" }
+```
+
 Path dependencies are supported. DCR will resolve them on build and generate `dcr.lock`.
 
 Incremental build note: object files are rebuilt when source `.c/.cpp` files change. Header dependency tracking is not implemented yet.

TODO.md

@@ -1,6 +1,9 @@
 # TODO
 
-- Add incremental builds
-- Add header dependency tracking for incremental builds (GCC/Clang: -MMD, MSVC: /showIncludes)
 - Add external package managers (Conan, vcpkg)
-- Support building static libraries (ar .a)
+- Linker script + direct linker control
+- Custom targets/steps
+- Cross-compilation and freestanding targets (-nostdinc, -nostdlib, custom target triple like i686-elf)
+- Mixed C + ASM in one project (compile .c and .s/.S sources together)
+- Per-member include directories in workspace (e.g. include paths for subprojects)
+- Build-time code generation (auto-generated headers, pre-build scripts)

docs/README.md

@@ -17,10 +17,14 @@ Current DCR focuses on a simple, predictable workflow:
   - C: `*.c`
   - C++: `*.cpp`, `*.cxx`, `*.cc`
 - Compiler selection from `dcr.toml` (`clang`, `gcc`, `cl`, `clang-cl`, etc.).
-- Two build kinds:
+- ASM support via `language = "asm"` (GCC/Clang, NASM, GAS).
+- Three build kinds:
   - `bin` (default)
   - `staticlib`
+  - `sharedlib`
 - Optional custom output directory via `build.target`.
+- Optional `build.platform` to pass architecture hints (`-march` / `/arch`).
+- Workspace builds via `[workspace]` with per-project `dcr.toml`.
 - Path dependencies with include/lib resolution and `dcr.lock` generation.
 
 ## Important behavior notes

docs/commands/dcr-build.md

@@ -17,7 +17,7 @@ dcr build --release
 3. Resolves path dependencies from `[dependencies]`.
 4. Creates required output directories.
 5. Recursively compiles sources from `src/`.
-6. Links final artifact (binary or static library).
+6. Links final artifact (binary or library).
 
 ## Config values used
 
@@ -27,6 +27,7 @@ dcr build --release
 - `build.standard`
 - `build.kind`
 - `build.target`
+- `build.platform`
 - `build.cflags`
 - `build.ldflags`
 
@@ -34,9 +35,12 @@ dcr build --release
 
 - `language = "c"` -> `*.c`
 - `language = "c++" | "cpp" | "cxx"` -> `*.cpp`, `*.cxx`, `*.cc`
+- `language = "asm"` -> `*.s`, `*.S`, `*.asm`
 
 ## Notes
 
 - The profile is selected from the first argument only.
 - Unknown profile flags return an error.
 - Incremental rebuild is based on source/object mtime comparison.
+- For `language = "asm"` with `compiler = "as"`/`"gas"`, use `.s` files (no preprocessing). For `.S`, use `gcc` or `clang`.
+- In workspace root, `dcr build` builds all members in dependency order.

docs/commands/dcr-clean.md

@@ -8,16 +8,18 @@ Removes build artifacts in `target/`.
 dcr clean
 dcr clean --debug
 dcr clean --release
+dcr clean --all
+dcr clean --release --all
 ```
 
 ## Behavior
 
 - Without arguments: removes entire `target/`.
 - With profile: removes only `target/<profile>/`.
+- With `--all`: also cleans all workspace members.
 
 ## Validation
 
 - `dcr.toml` must exist.
-- More than one argument is treated as error.
-- Unknown profile is treated as error.
+- Unknown flags are treated as error.
 - If `target` or selected profile directory does not exist, command prints a warning.

docs/commands/dcr-run.md

@@ -19,7 +19,7 @@ dcr run --release
 
 ## Restrictions
 
-- If `build.kind = "staticlib"`, `run` exits with error.
+- If `build.kind = "staticlib"` or `build.kind = "sharedlib"`, `run` exits with error.
 - The profile is selected from the first argument.
 
 ## On build failure

docs/configuration/build-profiles.md

@@ -18,12 +18,12 @@ dcr clean --debug
 
 ### GCC/Clang-like toolchains
 
-- `debug`: `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDEBUG`
+- `debug`: `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDCR_DEBUG`
 - `release`: `-O3 -DNDEBUG -march=native`
 
 ### MSVC toolchain
 
-- `debug`: `/Od /Zi /W4 /DDEBUG /Oy-`
+- `debug`: `/Od /Zi /W4 /DDCR_DEBUG /Oy-`
 - `release`: `/O2 /DNDEBUG`
 
 ## Artifacts
@@ -33,7 +33,25 @@ By default:
 - `target/debug/<name>` (or `.exe` on Windows)
 - `target/release/<name>` (or `.exe` on Windows)
 
+Default compiler flags:
+
+GCC/Clang:
+
+- `debug`: `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDCR_DEBUG`
+- `release`: `-O3 -DNDEBUG -march=native`
+
+MSVC:
+
+- `debug`: `/Od /Zi /W4 /DDCR_DEBUG /Oy-`
+- `release`: `/O2 /DNDEBUG`
+
 Static library mode (`kind = "staticlib"`):
 
 - Linux/macOS: `lib<name>.a`
 - Windows: `<name>.lib`
+
+Shared library mode (`kind = "sharedlib"`):
+
+- Linux: `lib<name>.so`
+- macOS: `lib<name>.dylib`
+- Windows: `<name>.dll`

docs/configuration/build-section.md

@@ -10,22 +10,35 @@ compiler = "clang"
 kind = "bin"
 # optional:
 # target = "./dist"
+# platform = "x86_64"
 # cflags = ["-Wall"]
 # ldflags = ["-lm"]
 ```
 
 ## Fields
 
-- `language` (string, required): `c`, `c++`, `cpp`, or `cxx`.
+- `language` (string, required): `c`, `c++`, `cpp`, `cxx`, or `asm`.
 - `standard` (string, required): language standard passed to compiler.
 - `compiler` (string, required): compiler command (for example `clang`, `gcc`, `cl`).
-- `kind` (string, required): `bin` or `staticlib`.
+- `kind` (string, required): `bin`, `staticlib`, or `sharedlib`.
 - `target` (string, optional): custom output directory for final artifact.
+- `platform` (string, optional): architecture hint for compiler (used for `-march` or `/arch`).
 - `cflags` (string array, optional): extra compile flags.
 - `ldflags` (string array, optional): extra link flags.
 
+## Toolchain section
+
+```toml
+[toolchain]
+cc = "clang"
+cxx = "clang++"
+as = "as"
+ar = "ar"
+ld = "ld"
+```
+
 ## Behavior notes
 
 - Compiler backend is selected by compiler string (`gcc`, `clang`, `cl`, `clang-cl`).
 - Empty or unknown compiler value falls back to clang-like build path.
-- `run` is not allowed for `kind = "staticlib"`.
+- `run` is not allowed for library kinds (`staticlib`, `sharedlib`).

docs/configuration/dcr.toml-overview.md

@@ -26,6 +26,9 @@ kind = "bin"
 - `[build]`
 - `[dependencies]`
 
+Workspace-only root:
+- `[workspace]` may be used instead of `[package]`/`[build]` for a workspace root.
+
 ## Required keys
 
 - `package.name`
@@ -35,7 +38,7 @@ kind = "bin"
 - `build.compiler`
 - `build.kind`
 
-`build.kind` must be either `bin` or `staticlib`.
+`build.kind` must be either `bin`, `staticlib`, or `sharedlib`.
 
 ## Optional keys
 
@@ -43,3 +46,5 @@ kind = "bin"
 - `build.cflags`
 - `build.ldflags`
 - dependency fields (`include`, `lib`, `libs`, `system`)
+- `[toolchain]` overrides (`cc`, `cxx`, `as`, `ar`, `ld`)
+- `[workspace]` members

docs/dependencies-and-build/compilers-and-linking.md

@@ -5,9 +5,11 @@
 DCR picks a backend from `build.compiler`:
 
 - contains `clang-cl` -> MSVC backend
+- equals `as` or contains `gas` -> GAS backend (standalone assembler)
 - contains `gcc` or `g++` -> GCC backend
 - contains `clang` or `clang++` -> Clang backend
 - equals `cl` or contains `msvc` -> MSVC backend
+- contains `nasm` -> NASM backend
 - otherwise -> Clang backend fallback
 
 ## Compilation model
@@ -16,6 +18,39 @@ DCR picks a backend from `build.compiler`:
 - Each source is compiled to `target/<profile>/obj/<relative-path>.o` (`.obj` on MSVC).
 - Recompile happens when source mtime is newer than object mtime.
 
+## Default build flags
+
+These flags are applied automatically based on profile and compiler backend.
+
+GCC/Clang:
+
+- `debug`: `-O0 -g -Wall -Wextra -fno-omit-frame-pointer -DDCR_DEBUG`
+- `release`: `-O3 -DNDEBUG -march=native`
+
+MSVC:
+
+- `debug`: `/Od /Zi /W4 /DDCR_DEBUG /Oy-`
+- `release`: `/O2 /DNDEBUG`
+
+## Platform hint
+
+If `build.platform` is set, DCR passes it as an architecture hint:
+
+- GCC/Clang: `-march=<platform>`
+- MSVC: maps to `/arch:*` for known values (`x86`, `i386`, `i486`, `i586`, `i686`, `sse2`, `avx`, `avx2`)
+
+## Toolchain overrides
+
+If `[toolchain]` is set, DCR uses its values to override compiler/linker tools:
+
+- `cc`, `cxx`, `as` override compilers for C/C++/ASM
+- `ar` overrides the archiver (used for `staticlib`)
+- `ld` overrides the linker (used by GCC/Clang/NASM/GAS backends)
+
+Environment overrides (highest priority):
+- `DCR_COMPILER` (all languages)
+- `DCR_CC`, `DCR_CXX`, `DCR_AS`, `DCR_AR`, `DCR_LD`
+
 ## Linking
 
 For `kind = "bin"`:
@@ -28,3 +63,9 @@ For `kind = "staticlib"`:
 
 - Linux/macOS (GCC/Clang): `ar rcs` creates `.a` archive.
 - Windows (MSVC): `lib` creates `.lib` archive.
+
+For `kind = "sharedlib"`:
+
+- Linux (GCC/Clang): `-shared` with output `.so`.
+- macOS (Clang): `-dynamiclib` with output `.dylib`.
+- Windows (MSVC): `/LD` with output `.dll`.

docs/dependencies-and-build/local-dependencies.md

@@ -11,6 +11,11 @@ For each dependency in `[dependencies]`, DCR:
 5. Synchronizes dependency files to `target/<profile>/deps/<dep-name>/`.
 6. Adds include/lib/link options to compile/link commands.
 
+### Profile placeholders
+
+`path`, `include`, and `lib` entries may use `{profile}` which expands to the active profile
+(`debug` or `release`).
+
 ## Failure cases
 
 - Dependency path is missing or not a directory.

docs/getting-started/build-and-run.md

@@ -37,10 +37,13 @@ Profile-only cleanup:
 ```sh
 dcr clean --debug
 dcr clean --release
+dcr clean --all
+dcr clean --release --all
 ```
 
 ## Notes
 
-- `run` is unavailable for `build.kind = "staticlib"`.
+- `run` is unavailable for `build.kind = "staticlib"` and `build.kind = "sharedlib"`.
 - Build profile flag is parsed from the first command argument.
 - Unknown profile flags produce an error.
+- In workspace root, `clean --all` cleans all member projects.

docs/getting-started/project-structure.md

@@ -35,5 +35,6 @@ project/
 - `target/<profile>/deps/`: synchronized copies of path dependencies.
 - `target/<profile>/<name>` (or `.exe` on Windows): output for `kind = "bin"`.
 - `target/<profile>/lib<name>.a` (or `<name>.lib` on Windows): output for `kind = "staticlib"`.
+- `target/<profile>/lib<name>.so` (or `.dylib` on macOS, `<name>.dll` on Windows): output for `kind = "sharedlib"`.
 
 If `build.target` is set, the final artifact is written to that custom directory, while object cache still stays in `target/<profile>/obj`.

docs/reference-and-help/cli-reference.md

@@ -7,7 +7,7 @@ dcr new <name>
 dcr init
 dcr build [--debug|--release]
 dcr run [--debug|--release]
-dcr clean [--debug|--release]
+dcr clean [--debug|--release] [--all]
 dcr --help
 dcr --version
 dcr --update
@@ -18,7 +18,7 @@ dcr --update
 - Most commands parse profile from the first argument.
 - `new` requires exactly one argument.
 - `init` and `--update` do not accept extra arguments.
-- `clean` accepts at most one argument.
+- `clean` accepts `--debug|--release` and optional `--all`.
 
 ## Exit behavior overview
 

docs/reference-and-help/config-reference.md

@@ -8,14 +8,25 @@ name = "string"      # required
 version = "string"   # required
 
 [build]
-language = "c|c++|cpp|cxx"     # required
+language = "c|c++|cpp|cxx|asm"     # required
 standard = "string"            # required
 compiler = "string"            # required
-kind = "bin|staticlib"         # required
+kind = "bin|staticlib|sharedlib"         # required
 target = "string"              # optional
+platform = "string"            # optional
 cflags = ["string", "..."]     # optional
 ldflags = ["string", "..."]    # optional
 
+[toolchain]
+cc = "string"   # optional
+cxx = "string"  # optional
+as = "string"   # optional
+ar = "string"   # optional
+ld = "string"   # optional
+
+[workspace]
+name = { path = "string", deps = ["string", "..."] }
+
 [dependencies]
 name = {
   path = "string",              # required for each dependency
@@ -29,7 +40,7 @@ name = {
 
 - `[package]`, `[build]`, `[dependencies]` must exist.
 - Required string fields must be non-empty.
-- `build.kind` must be `bin` or `staticlib`.
+- `build.kind` must be `bin`, `staticlib`, or `sharedlib`.
 - Dependency fields `include/lib/libs` must be string arrays when provided.
 
 ## Generated defaults (`dcr new` / `dcr init`)

src/cli/clean.rs

@@ -1,63 +1,138 @@
 use crate::config::flags;
-use crate::utils::fs::check_dir;
+use crate::core::config::Config;
+use crate::core::workspace::parse_workspace;
+use crate::utils::fs::{check_dir, find_project_root};
 use crate::utils::log::{error, warn};
 use crate::utils::text::{BOLD_GREEN, colored};
 use std::fs;
+use std::path::Path;
 
 pub fn clean(args: &[String]) -> i32 {
-    let project_name = std::env::current_dir()
-        .ok()
-        .and_then(|p| p.file_name().map(|v| v.to_string_lossy().to_string()))
-        .unwrap_or_else(|| "project".to_string());
-    let items = check_dir(None).unwrap_or_default();
-
-    if args.len() > 1 {
-        error("Unknown argument");
-        return 1;
-    }
-    if !items.contains(&"dcr.toml".to_string()) {
-        error("dcr.toml file not found");
-        return 1;
-    }
-
-    println!(
-        "    Cleaning project `{}`",
-        colored(&project_name, BOLD_GREEN)
-    );
-    if !items.contains(&"target".to_string()) {
-        warn("Directory target not found");
-        return 1;
-    }
-
-    if let Some(arg) = args.first() {
-        let mut profile = arg.clone();
-        if profile.starts_with("--") {
-            profile = profile.trim_start_matches("--").to_string();
-        }
-        if flags(&profile).is_none() {
-            error("Unknown profile");
+    let start_dir = match std::env::current_dir() {
+        Ok(dir) => dir,
+        Err(_) => {
+            error("Failed to determine current directory");
             return 1;
         }
-
-        let target_items = check_dir(Some("target")).unwrap_or_default();
-        if !target_items.contains(&profile) {
-            warn(&format!("Directory target/{profile} not found"));
+    };
+    let root = match find_project_root(&start_dir) {
+        Ok(Some(dir)) => dir,
+        Ok(None) => {
+            error("dcr.toml file not found");
             return 1;
         }
+        Err(_) => {
+            error("Failed to find project root");
+            return 1;
+        }
+    };
+    let flags = match parse_clean_flags(args) {
+        Ok(v) => v,
+        Err(msg) => {
+            error(&msg);
+            return 1;
+        }
+    };
 
-        println!("    Profile: {}", colored(&profile, BOLD_GREEN));
-        let _ = fs::remove_dir_all(format!("target/{profile}"));
+    match with_dir(&root, || clean_from_root(&root, &flags)) {
+        Ok(()) => 0,
+        Err(msg) => {
+            error(&msg);
+            1
+        }
+    }
+}
+
+struct CleanFlags {
+    profile: Option<String>,
+    all: bool,
+}
+
+fn parse_clean_flags(args: &[String]) -> Result<CleanFlags, String> {
+    let mut profile: Option<String> = None;
+    let mut all = false;
+    for arg in args {
+        if arg == "--all" {
+            all = true;
+            continue;
+        }
+        if arg.starts_with("--") {
+            let candidate = arg.trim_start_matches("--").to_string();
+            if flags(&candidate).is_some() {
+                if profile.is_some() {
+                    return Err("Duplicate profile flag".to_string());
+                }
+                profile = Some(candidate);
+                continue;
+            }
+        }
+        return Err("Unknown argument".to_string());
+    }
+    Ok(CleanFlags { profile, all })
+}
+
+fn clean_from_root(root: &Path, flags: &CleanFlags) -> Result<(), String> {
+    let config = Config::open("./dcr.toml").map_err(|err| err.to_string())?;
+    if flags.all
+        && let Some(workspace) = parse_workspace(&config, root)?
+    {
+        for member in &workspace.members {
+            clean_project_at(&member.path, flags.profile.as_deref())?;
+        }
+    }
+    clean_project_at(root, flags.profile.as_deref())
+}
+
+fn clean_project_at(project_root: &Path, profile: Option<&str>) -> Result<(), String> {
+    with_dir(project_root, || {
+        let project_name = std::env::current_dir()
+            .ok()
+            .and_then(|p| p.file_name().map(|v| v.to_string_lossy().to_string()))
+            .unwrap_or_else(|| "project".to_string());
+        let items = check_dir(None).map_err(|_| "Failed to read project directory".to_string())?;
+        if !items.contains(&"dcr.toml".to_string()) {
+            return Err("dcr.toml file not found".to_string());
+        }
         println!(
-            "{} Removed directory target/{profile}",
+            "    Cleaning project `{}`",
+            colored(&project_name, BOLD_GREEN)
+        );
+        if !items.contains(&"target".to_string()) {
+            warn("Directory target not found");
+            return Ok(());
+        }
+
+        if let Some(profile) = profile {
+            let target_items = check_dir(Some("target")).unwrap_or_default();
+            if !target_items.contains(&profile.to_string()) {
+                warn(&format!("Directory target/{profile} not found"));
+                return Ok(());
+            }
+            println!("    Profile: {}", colored(profile, BOLD_GREEN));
+            let _ = fs::remove_dir_all(format!("target/{profile}"));
+            println!(
+                "{} Removed directory target/{profile}",
+                colored("\n    ✔", BOLD_GREEN)
+            );
+            return Ok(());
+        }
+
+        let _ = fs::remove_dir_all("target");
+        println!(
+            "{} Removed directory target",
             colored("\n    ✔", BOLD_GREEN)
         );
-        return 0;
-    }
-
-    let _ = fs::remove_dir_all("target");
-    println!(
-        "{} Removed directory target",
-        colored("\n    ✔", BOLD_GREEN)
-    );
-    0
+        Ok(())
+    })
+}
+
+fn with_dir<F, T>(dir: &Path, f: F) -> Result<T, String>
+where
+    F: FnOnce() -> Result<T, String>,
+{
+    let prev = std::env::current_dir().map_err(|_| "Failed to get current dir".to_string())?;
+    std::env::set_current_dir(dir).map_err(|_| "Failed to change directory".to_string())?;
+    let result = f();
+    let _ = std::env::set_current_dir(prev);
+    result
 }

src/cli/run.rs

@@ -2,25 +2,40 @@ use crate::cli::build::build;
 use crate::config::{PROFILE, flags};
 use crate::core::config::Config;
 use crate::core::runner::run_binary;
-use crate::utils::fs::check_dir;
+use crate::utils::fs::find_project_root;
 use crate::utils::log::{error, warn};
 use crate::utils::text::{BOLD_GREEN, colored};
+use std::path::Path;
 
 pub fn run(args: &[String]) -> i32 {
     let mut active_profile = PROFILE.to_string();
 
-    let items = check_dir(None).unwrap_or_default();
-    if !items.contains(&"dcr.toml".to_string()) {
-        error("dcr.toml file not found");
-        return 1;
-    }
-
-    let config = match Config::open("./dcr.toml") {
-        Ok(cfg) => cfg,
+    let start_dir = match std::env::current_dir() {
+        Ok(dir) => dir,
         Err(_) => {
+            error("Failed to determine current directory");
+            return 1;
+        }
+    };
+    let root = match find_project_root(&start_dir) {
+        Ok(Some(dir)) => dir,
+        Ok(None) => {
             error("dcr.toml file not found");
             return 1;
         }
+        Err(_) => {
+            error("Failed to find project root");
+            return 1;
+        }
+    };
+    let config = match with_dir(&root, || {
+        Config::open("./dcr.toml").map_err(|err| err.to_string())
+    }) {
+        Ok(cfg) => cfg,
+        Err(err) => {
+            error(&err);
+            return 1;
+        }
     };
     let project_name: &str = config
         .get("package.name")
@@ -51,8 +66,9 @@ pub fn run(args: &[String]) -> i32 {
         }
     }
 
-    if build_kind.trim() == "staticlib" {
-        error("Cannot run static library");
+    let kind = build_kind.trim();
+    if kind == "staticlib" || kind == "sharedlib" {
+        error("Cannot run library build");
         return 1;
     }
     let build_status = build(args);
@@ -71,3 +87,14 @@ pub fn run(args: &[String]) -> i32 {
     error("Fix errors in the code to run the project");
     1
 }
+
+fn with_dir<F, T>(dir: &Path, f: F) -> Result<T, String>
+where
+    F: FnOnce() -> Result<T, String>,
+{
+    let prev = std::env::current_dir().map_err(|_| "Failed to get current dir".to_string())?;
+    std::env::set_current_dir(dir).map_err(|_| "Failed to change directory".to_string())?;
+    let result = f();
+    let _ = std::env::set_current_dir(prev);
+    result
+}

src/config.rs

@@ -16,7 +16,7 @@ pub fn flags(profile: &str) -> Option<&'static [&'static str]> {
             "-Wall",
             "-Wextra",
             "-fno-omit-frame-pointer",
-            "-DDEBUG",
+            "-DDCR_DEBUG",
         ]),
         _ => None,
     }

src/core/builder/common.rs

@@ -0,0 +1,428 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+pub fn collect_sources(
+    extensions: &[&str],
+    exclude_dirs: &[PathBuf],
+) -> Result<Vec<String>, String> {
+    let mut sources = Vec::new();
+    collect_sources_rec("./src", extensions, &mut sources, exclude_dirs)?;
+    sources.sort();
+    if sources.is_empty() {
+        return Err("No source files found in ./src".to_string());
+    }
+    Ok(sources)
+}
+
+fn collect_sources_rec(
+    dir: &str,
+    extensions: &[&str],
+    out: &mut Vec<String>,
+    exclude_dirs: &[PathBuf],
+) -> Result<(), String> {
+    let dir_path = Path::new(dir);
+    let full_dir = if dir_path.is_absolute() {
+        dir_path.to_path_buf()
+    } else {
+        std::env::current_dir()
+            .map_err(|err| format!("src dir error: {err}"))?
+            .join(dir_path)
+    };
+    if is_excluded(&full_dir, exclude_dirs) {
+        return Ok(());
+    }
+    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
+    for entry in entries {
+        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
+        let path = entry.path();
+        if path.is_dir() {
+            if is_excluded(&path, exclude_dirs) {
+                continue;
+            }
+            collect_sources_rec(&path.to_string_lossy(), extensions, out, exclude_dirs)?;
+            continue;
+        }
+        if !path.is_file() {
+            continue;
+        }
+        let ext_raw = path.extension().and_then(|v| v.to_str()).unwrap_or("");
+        let ext_lower = ext_raw.to_lowercase();
+        let matched = extensions
+            .iter()
+            .any(|allowed| *allowed == ext_raw || *allowed == ext_lower);
+        if matched {
+            out.push(normalize_source_path(&path));
+        }
+    }
+    Ok(())
+}
+
+pub fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool {
+    exclude_dirs.iter().any(|dir| path.starts_with(dir))
+}
+
+pub fn normalize_source_path(path: &Path) -> String {
+    if !path.is_absolute() {
+        return path.to_string_lossy().to_string();
+    }
+    if let Ok(base) = std::env::current_dir()
+        && let Ok(rel) = path.strip_prefix(&base)
+    {
+        return format!("./{}", rel.to_string_lossy());
+    }
+    path.to_string_lossy().to_string()
+}
+
+pub fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
+    let src_path = Path::new(source);
+    let rel = src_path
+        .strip_prefix("./src")
+        .or_else(|_| src_path.strip_prefix("src"))
+        .unwrap_or(src_path);
+    let mut out = obj_dir.join(rel);
+    out.set_extension(obj_ext.trim_start_matches('.'));
+    out.to_string_lossy().to_string()
+}
+
+pub fn needs_rebuild(source: &str, object: &str) -> bool {
+    let src_time = fs::metadata(source).and_then(|m| m.modified());
+    let obj_time = fs::metadata(object).and_then(|m| m.modified());
+    let o_time = match obj_time {
+        Ok(t) => t,
+        Err(_) => return true,
+    };
+    match src_time {
+        Ok(s) if s > o_time => return true,
+        Err(_) => return true,
+        _ => {}
+    }
+
+    let d_file = PathBuf::from(object).with_extension("d");
+    if let Ok(content) = fs::read_to_string(&d_file) {
+        let deps = parse_d_file(&content);
+        for dep in deps {
+            let dep_path = Path::new(&dep);
+            if dep_path == Path::new(object) || dep_path == Path::new(source) {
+                continue;
+            }
+            if let Ok(dep_meta) = fs::metadata(dep_path) {
+                if let Ok(dep_time) = dep_meta.modified()
+                    && dep_time > o_time
+                {
+                    return true;
+                }
+            } else {
+                return true; // Missing dependency triggers rebuild
+            }
+        }
+    }
+    false
+}
+
+fn parse_d_file(content: &str) -> Vec<String> {
+    let mut deps = Vec::new();
+    let text = content.replace("\\\n", " ").replace("\\\r\n", " ");
+    let mut target_end = 0;
+    let chars: Vec<char> = text.chars().collect();
+    for i in 0..chars.len() {
+        if chars[i] == ':' {
+            if i == 1
+                && chars[0].is_ascii_alphabetic()
+                && i + 1 < chars.len()
+                && (chars[i + 1] == '\\' || chars[i + 1] == '/')
+            {
+                continue; // Windows drive letter
+            }
+            target_end = i + 1;
+            break;
+        }
+    }
+
+    let deps_str = if target_end > 0 {
+        &text[target_end..]
+    } else {
+        &text
+    };
+
+    let mut current_path = String::new();
+    let mut in_escape = false;
+
+    for c in deps_str.chars() {
+        if in_escape {
+            if c != '\n' && c != '\r' {
+                current_path.push(c);
+            }
+            in_escape = false;
+        } else if c == '\\' {
+            in_escape = true;
+        } else if c.is_whitespace() {
+            if !current_path.is_empty() {
+                deps.push(current_path.clone());
+                current_path.clear();
+            }
+        } else {
+            current_path.push(c);
+        }
+    }
+    if !current_path.is_empty() {
+        deps.push(current_path);
+    }
+    deps
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use std::path::PathBuf;
+    use std::sync::Mutex;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    static TEST_COUNTER: AtomicUsize = AtomicUsize::new(0);
+    static CWD_LOCK: Mutex<()> = Mutex::new(());
+
+    fn temp_dir(prefix: &str) -> PathBuf {
+        let n = TEST_COUNTER.fetch_add(1, Ordering::SeqCst);
+        let dir = std::env::temp_dir().join(format!("dcr_test_{prefix}_{n}"));
+        let _ = fs::remove_dir_all(&dir);
+        fs::create_dir_all(&dir).unwrap();
+        dir
+    }
+
+    #[test]
+    fn object_path_basic() {
+        let obj_dir = Path::new("target/debug/obj");
+        let result = object_path(obj_dir, "./src/main.c", "o");
+        assert_eq!(result, "target/debug/obj/main.o");
+    }
+
+    #[test]
+    fn object_path_nested() {
+        let obj_dir = Path::new("target/debug/obj");
+        let result = object_path(obj_dir, "./src/core/utils.c", "o");
+        assert_eq!(result, "target/debug/obj/core/utils.o");
+    }
+
+    #[test]
+    fn object_path_no_prefix() {
+        let obj_dir = Path::new("target/debug/obj");
+        let result = object_path(obj_dir, "src/main.c", "o");
+        assert_eq!(result, "target/debug/obj/main.o");
+    }
+
+    #[test]
+    fn object_path_msvc_ext() {
+        let obj_dir = Path::new("target/debug/obj");
+        let result = object_path(obj_dir, "./src/main.c", "obj");
+        assert_eq!(result, "target/debug/obj/main.obj");
+    }
+
+    #[test]
+    fn needs_rebuild_no_object() {
+        let dir = temp_dir("rebuild_no_obj");
+        let src = dir.join("test.c");
+        fs::write(&src, "int main() {}").unwrap();
+        let obj = dir.join("test.o");
+        assert!(needs_rebuild(
+            &src.to_string_lossy(),
+            &obj.to_string_lossy()
+        ));
+    }
+
+    #[test]
+    fn needs_rebuild_fresh() {
+        let dir = temp_dir("rebuild_fresh");
+        let src = dir.join("test.c");
+        let obj = dir.join("test.o");
+        fs::write(&src, "int main() {}").unwrap();
+        // Sleep briefly to ensure mtime difference
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write(&obj, "").unwrap();
+        assert!(!needs_rebuild(
+            &src.to_string_lossy(),
+            &obj.to_string_lossy()
+        ));
+    }
+
+    #[test]
+    fn needs_rebuild_stale() {
+        let dir = temp_dir("rebuild_stale");
+        let src = dir.join("test.c");
+        let obj = dir.join("test.o");
+        fs::write(&obj, "").unwrap();
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write(&src, "int main() { return 1; }").unwrap();
+        assert!(needs_rebuild(
+            &src.to_string_lossy(),
+            &obj.to_string_lossy()
+        ));
+    }
+
+    #[test]
+    fn is_excluded_match() {
+        let excluded = vec![PathBuf::from("/project/src/vendor")];
+        assert!(is_excluded(Path::new("/project/src/vendor"), &excluded));
+        assert!(is_excluded(
+            Path::new("/project/src/vendor/lib.c"),
+            &excluded
+        ));
+    }
+
+    #[test]
+    fn is_excluded_no_match() {
+        let excluded = vec![PathBuf::from("/project/src/vendor")];
+        assert!(!is_excluded(Path::new("/project/src/main.c"), &excluded));
+        assert!(!is_excluded(Path::new("/other/vendor"), &excluded));
+    }
+
+    #[test]
+    fn collect_sources_c_files() {
+        let dir = temp_dir("collect_c");
+        let src = dir.join("src");
+        fs::create_dir_all(&src).unwrap();
+        fs::write(src.join("main.c"), "").unwrap();
+        fs::write(src.join("utils.c"), "").unwrap();
+        fs::write(src.join("README.md"), "").unwrap(); // should be ignored
+
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let result = collect_sources(&["c"], &[]);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 2);
+        assert!(sources.iter().any(|s| s.ends_with("main.c")));
+        assert!(sources.iter().any(|s| s.ends_with("utils.c")));
+    }
+
+    #[test]
+    fn collect_sources_cpp_files() {
+        let dir = temp_dir("collect_cpp");
+        let src = dir.join("src");
+        fs::create_dir_all(&src).unwrap();
+        fs::write(src.join("main.cpp"), "").unwrap();
+        fs::write(src.join("helper.cxx"), "").unwrap();
+        fs::write(src.join("other.cc"), "").unwrap();
+        fs::write(src.join("skip.c"), "").unwrap(); // should be ignored
+
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let result = collect_sources(&["cpp", "cxx", "cc"], &[]);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 3);
+    }
+
+    #[test]
+    fn collect_sources_empty_dir() {
+        let dir = temp_dir("collect_empty");
+        let src = dir.join("src");
+        fs::create_dir_all(&src).unwrap();
+
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let result = collect_sources(&["c"], &[]);
+        std::env::set_current_dir(prev).unwrap();
+
+        assert!(result.is_err(), "empty src should return error");
+    }
+
+    #[test]
+    fn collect_sources_respects_excludes() {
+        let dir = temp_dir("collect_exclude");
+        let src = dir.join("src");
+        let vendor = src.join("vendor");
+        fs::create_dir_all(&vendor).unwrap();
+        fs::write(src.join("main.c"), "").unwrap();
+        fs::write(vendor.join("lib.c"), "").unwrap(); // should be excluded
+
+        let exclude = vec![vendor.clone()];
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let result = collect_sources(&["c"], &exclude);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 1);
+        assert!(sources[0].ends_with("main.c"));
+    }
+
+    #[test]
+    fn collect_sources_nested() {
+        let dir = temp_dir("collect_nested");
+        let src = dir.join("src");
+        let sub = src.join("core").join("deep");
+        fs::create_dir_all(&sub).unwrap();
+        fs::write(src.join("main.c"), "").unwrap();
+        fs::write(sub.join("nested.c"), "").unwrap();
+
+        let _guard = CWD_LOCK.lock().unwrap();
+        let prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let result = collect_sources(&["c"], &[]);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 2);
+    }
+
+    #[test]
+    fn normalize_relative_path() {
+        let result = normalize_source_path(Path::new("./src/main.c"));
+        assert_eq!(result, "./src/main.c");
+    }
+
+    #[test]
+    fn parse_d_file_gcc_format() {
+        let content = "target/obj/main.o: src/main.c src/utils.h \\\n src/core/types.h";
+        let deps = parse_d_file(content);
+        assert_eq!(deps, vec!["src/main.c", "src/utils.h", "src/core/types.h"]);
+    }
+
+    #[test]
+    fn parse_d_file_msvc_format() {
+        let content = "target/obj/main.obj: \\\n  C:/sdk/include/windows.h \\\n  src/main.c";
+        let deps = parse_d_file(content);
+        assert_eq!(deps, vec!["C:/sdk/include/windows.h", "src/main.c"]);
+    }
+
+    #[test]
+    fn needs_rebuild_header_modified() {
+        let dir = temp_dir("rebuild_header");
+        let src = dir.join("test.c");
+        let header = dir.join("test.h");
+        let obj = dir.join("test.o");
+        let d_file = dir.join("test.d");
+
+        fs::write(&src, "int main() {}").unwrap();
+        fs::write(&header, "#define A 1").unwrap();
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write(&obj, "").unwrap();
+
+        let d_content = format!(
+            "{}: {} {}",
+            obj.to_string_lossy(),
+            src.to_string_lossy(),
+            header.to_string_lossy()
+        );
+        fs::write(&d_file, d_content).unwrap();
+
+        assert!(
+            !needs_rebuild(&src.to_string_lossy(), &obj.to_string_lossy()),
+            "should be fresh"
+        );
+
+        std::thread::sleep(std::time::Duration::from_millis(50));
+        fs::write(&header, "#define A 2").unwrap(); // modify header
+
+        assert!(
+            needs_rebuild(&src.to_string_lossy(), &obj.to_string_lossy()),
+            "changed header should trigger rebuild"
+        );
+    }
+}

src/core/builder/gas.rs

@@ -0,0 +1,125 @@
+use crate::core::builder::BuildContext;
+use crate::core::builder::common;
+use crate::platform;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+use std::time::Instant;
+
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    if ctx.language.to_lowercase().as_str() != "asm" {
+        return Err("GAS backend requires build.language = \"asm\"".to_string());
+    }
+    let assembler = if ctx.compiler.is_empty() {
+        "as"
+    } else {
+        ctx.compiler
+    };
+    let start_time = Instant::now();
+    let sources = collect_sources(ctx)?;
+    let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
+    let objects = build_objects(assembler, &sources, &obj_dir, ctx, "o")?;
+
+    if ctx.kind == "staticlib" {
+        let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+        let archiver = ctx.archiver.unwrap_or(if cfg!(target_os = "windows") {
+            "lib"
+        } else {
+            "ar"
+        });
+        let mut cmd = Command::new(archiver);
+        if cfg!(target_os = "windows") && archiver == "lib" {
+            cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
+        } else {
+            cmd.arg("rcs").arg(&lib_path);
+        }
+        for obj in &objects {
+            cmd.arg(obj);
+        }
+        if std::env::var("DCR_DEBUG").is_ok() {
+            eprintln!("[dcr] {:?}", cmd);
+        }
+        match cmd.status() {
+            Ok(status) if status.success() => {
+                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+                return Ok(elapsed);
+            }
+            Ok(_) => return Err("Build failed".to_string()),
+            Err(err) => return Err(format!("Build failed: {err}")),
+        }
+    }
+
+    let mut cmd = Command::new(ctx.linker.unwrap_or("cc"));
+    if ctx.kind == "sharedlib" {
+        if cfg!(target_os = "macos") {
+            cmd.arg("-dynamiclib");
+        } else {
+            cmd.arg("-shared");
+        }
+    }
+    for obj in &objects {
+        cmd.arg(obj);
+    }
+    for dir in ctx.lib_dirs {
+        cmd.arg(format!("-L{dir}"));
+    }
+    for lib in ctx.libs {
+        cmd.arg(format!("-l{lib}"));
+    }
+    for flag in ctx.ldflags {
+        cmd.arg(flag);
+    }
+    let out_path = if ctx.kind == "sharedlib" {
+        platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    } else {
+        platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    };
+    cmd.arg("-o").arg(out_path);
+
+    if std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+    match cmd.status() {
+        Ok(status) if status.success() => {
+            let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+            Ok(elapsed)
+        }
+        Ok(_) => Err("Build failed".to_string()),
+        Err(err) => Err(format!("Build failed: {err}")),
+    }
+}
+
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    // GAS handles only lowercase .s files
+    common::collect_sources(&["s"], ctx.exclude_dirs)
+}
+
+fn build_objects(
+    assembler: &str,
+    sources: &[String],
+    obj_dir: &Path,
+    ctx: &BuildContext,
+    obj_ext: &str,
+) -> Result<Vec<String>, String> {
+    let mut objects = Vec::new();
+    for source in sources {
+        let obj_path = common::object_path(obj_dir, source, obj_ext);
+        if let Some(parent) = Path::new(&obj_path).parent() {
+            fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+        }
+        if common::needs_rebuild(source, &obj_path) {
+            let mut cmd = Command::new(assembler);
+            cmd.arg(source).arg("-o").arg(&obj_path);
+            for flag in ctx.cflags {
+                cmd.arg(flag);
+            }
+            match cmd.status() {
+                Ok(status) if status.success() => {}
+                Ok(_) => return Err("Build failed".to_string()),
+                Err(err) => return Err(format!("Build failed: {err}")),
+            }
+        }
+        objects.push(obj_path);
+    }
+    Ok(objects)
+}

src/core/builder/gcc.rs

@@ -1,183 +0,0 @@
-use crate::core::builder::BuildContext;
-use crate::platform;
-use std::fs;
-use std::path::Path;
-use std::process::Command;
-use std::time::Instant;
-
-pub fn build(ctx: &BuildContext) -> Result<f64, String> {
-    let compiler = if ctx.compiler.is_empty() {
-        "cc"
-    } else {
-        ctx.compiler
-    };
-    let start_time = Instant::now();
-    let sources = collect_sources(ctx.language)?;
-    let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
-    let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o")?;
-
-    if ctx.kind == "staticlib" {
-        let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
-        let mut cmd = Command::new("ar");
-        cmd.arg("rcs").arg(&lib_path);
-        for obj in &objects {
-            cmd.arg(obj);
-        }
-        match cmd.status() {
-            Ok(status) if status.success() => {
-                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
-                return Ok(elapsed);
-            }
-            Ok(_) => return Err("Build failed".to_string()),
-            Err(err) => return Err(format!("Build failed: {err}")),
-        }
-    }
-
-    let mut cmd = Command::new(compiler);
-    for obj in &objects {
-        cmd.arg(obj);
-    }
-    for flag in default_flags(ctx.profile) {
-        cmd.arg(flag);
-    }
-    for flag in ctx.cflags {
-        cmd.arg(flag);
-    }
-    for dir in ctx.lib_dirs {
-        cmd.arg(format!("-L{dir}"));
-    }
-    for lib in ctx.libs {
-        cmd.arg(format!("-l{lib}"));
-    }
-    for flag in ctx.ldflags {
-        cmd.arg(flag);
-    }
-    cmd.arg("-o").arg(platform::bin_path(
-        ctx.profile,
-        ctx.project_name,
-        ctx.target_dir,
-    ));
-
-    match cmd.status() {
-        Ok(status) if status.success() => {
-            let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
-            Ok(elapsed)
-        }
-        Ok(_) => Err("Build failed".to_string()),
-        Err(err) => Err(format!("Build failed: {err}")),
-    }
-}
-
-fn collect_sources(language: &str) -> Result<Vec<String>, String> {
-    let lang = language.to_lowercase();
-    let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources)?;
-    sources.sort();
-    if sources.is_empty() {
-        return Err("No source files found in ./src".to_string());
-    }
-    Ok(sources)
-}
-
-fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(), String> {
-    let entries = fs::read_dir(dir).map_err(|err| format!("src dir error: {err}"))?;
-    for entry in entries {
-        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
-        let path = entry.path();
-        if path.is_dir() {
-            collect_sources_rec(&path.to_string_lossy(), lang, out)?;
-            continue;
-        }
-        if !path.is_file() {
-            continue;
-        }
-        let ext = path
-            .extension()
-            .and_then(|v| v.to_str())
-            .unwrap_or("")
-            .to_lowercase();
-        let file = path.to_string_lossy().to_string();
-        let allowed = (lang == "c" && ext == "c")
-            || ((lang == "c++" || lang == "cpp" || lang == "cxx")
-                && (ext == "cpp" || ext == "cxx" || ext == "cc"));
-        if allowed {
-            out.push(file);
-        }
-    }
-    Ok(())
-}
-
-fn default_flags(profile: &str) -> &'static [&'static str] {
-    match profile {
-        "release" => &["-O3", "-DNDEBUG", "-march=native"],
-        "debug" => &[
-            "-O0",
-            "-g",
-            "-Wall",
-            "-Wextra",
-            "-fno-omit-frame-pointer",
-            "-DDEBUG",
-        ],
-        _ => &[],
-    }
-}
-
-fn build_objects(
-    compiler: &str,
-    sources: &[String],
-    obj_dir: &Path,
-    ctx: &BuildContext,
-    obj_ext: &str,
-) -> Result<Vec<String>, String> {
-    let mut objects = Vec::new();
-    for source in sources {
-        let obj_path = object_path(obj_dir, source, obj_ext);
-        if let Some(parent) = Path::new(&obj_path).parent() {
-            fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
-        }
-        if needs_rebuild(source, &obj_path) {
-            let mut cmd = Command::new(compiler);
-            cmd.arg("-c").arg(source).arg("-o").arg(&obj_path);
-            if !ctx.standard.is_empty() {
-                cmd.arg(format!("-std={}", ctx.standard));
-            }
-            for flag in default_flags(ctx.profile) {
-                cmd.arg(flag);
-            }
-            for flag in ctx.cflags {
-                cmd.arg(flag);
-            }
-            for dir in ctx.include_dirs {
-                cmd.arg(format!("-I{dir}"));
-            }
-            match cmd.status() {
-                Ok(status) if status.success() => {}
-                Ok(_) => return Err("Build failed".to_string()),
-                Err(err) => return Err(format!("Build failed: {err}")),
-            }
-        }
-        objects.push(obj_path);
-    }
-    Ok(objects)
-}
-
-fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
-    let src_path = Path::new(source);
-    let rel = src_path
-        .strip_prefix("./src")
-        .or_else(|_| src_path.strip_prefix("src"))
-        .unwrap_or(src_path);
-    let mut out = obj_dir.join(rel);
-    out.set_extension(obj_ext.trim_start_matches('.'));
-    out.to_string_lossy().to_string()
-}
-
-fn needs_rebuild(source: &str, object: &str) -> bool {
-    let src_time = fs::metadata(source).and_then(|m| m.modified());
-    let obj_time = fs::metadata(object).and_then(|m| m.modified());
-    match (src_time, obj_time) {
-        (Ok(s), Ok(o)) => s > o,
-        (Ok(_), Err(_)) => true,
-        _ => true,
-    }
-}

src/core/builder/mod.rs

@@ -1,6 +1,8 @@
-pub mod clang;
-pub mod gcc;
+pub mod common;
+pub mod gas;
 pub mod msvc;
+pub mod nasm;
+pub mod unix_cc;
 
 pub struct BuildContext<'a> {
     pub profile: &'a str,
@@ -10,6 +12,10 @@ pub struct BuildContext<'a> {
     pub standard: &'a str,
     pub target_dir: Option<&'a str>,
     pub kind: &'a str,
+    pub platform: Option<&'a str>,
+    pub linker: Option<&'a str>,
+    pub archiver: Option<&'a str>,
+    pub exclude_dirs: &'a [std::path::PathBuf],
     pub include_dirs: &'a [String],
     pub lib_dirs: &'a [String],
     pub libs: &'a [String],
@@ -22,14 +28,28 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     if compiler.contains("clang-cl") {
         return msvc::build(ctx);
     }
-    if compiler.contains("gcc") || compiler.contains("g++") {
-        return gcc::build(ctx);
+    if compiler == "as" || compiler.contains("gas") {
+        return gas::build(ctx);
     }
-    if compiler.contains("clang") || compiler.contains("clang++") {
-        return clang::build(ctx);
+    if compiler.contains("nasm") {
+        return nasm::build(ctx);
     }
     if compiler == "cl" || compiler.contains("msvc") {
         return msvc::build(ctx);
     }
-    clang::build(ctx)
+    unix_cc::build(ctx)
+}
+
+pub fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    let compiler = ctx.compiler.to_lowercase();
+    if compiler.contains("clang-cl") || compiler == "cl" || compiler.contains("msvc") {
+        return msvc::collect_sources(ctx);
+    }
+    if compiler == "as" || compiler.contains("gas") {
+        return gas::collect_sources(ctx);
+    }
+    if compiler.contains("nasm") {
+        return nasm::collect_sources(ctx);
+    }
+    unix_cc::collect_sources(ctx)
 }

src/core/builder/msvc.rs

@@ -1,4 +1,5 @@
 use crate::core::builder::BuildContext;
+use crate::core::builder::common;
 use crate::platform;
 use std::fs;
 use std::path::Path;
@@ -11,18 +12,24 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     } else {
         ctx.compiler
     };
+    if ctx.language.to_lowercase() == "asm" {
+        return Err("MSVC backend does not support build.language = \"asm\"".to_string());
+    }
     let start_time = Instant::now();
-    let sources = collect_sources(ctx.language)?;
+    let sources = collect_sources(ctx)?;
     let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
     let objects = build_objects(compiler, &sources, &obj_dir, ctx, "obj")?;
 
     if ctx.kind == "staticlib" {
         let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
-        let mut cmd = Command::new("lib");
+        let mut cmd = Command::new(ctx.archiver.unwrap_or("lib"));
         cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
         for obj in &objects {
             cmd.arg(obj);
         }
+        if std::env::var("DCR_DEBUG").is_ok() {
+            eprintln!("[dcr] {:?}", cmd);
+        }
         match cmd.status() {
             Ok(status) if status.success() => {
                 let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
@@ -35,6 +42,9 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
 
     let mut cmd = Command::new(compiler);
     cmd.arg("/nologo");
+    if ctx.kind == "sharedlib" {
+        cmd.arg("/LD");
+    }
     match ctx.language.to_lowercase().as_str() {
         "c" => {
             cmd.arg("/TC");
@@ -77,11 +87,16 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
             cmd.arg(flag);
         }
     }
-    cmd.arg(format!(
-        "/Fe:{}",
+    let out_path = if ctx.kind == "sharedlib" {
+        platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    } else {
         platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
-    ));
+    };
+    cmd.arg(format!("/Fe:{out_path}"));
 
+    if std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
     match cmd.status() {
         Ok(status) if status.success() => {
             let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
@@ -92,43 +107,18 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
 }
 
-fn collect_sources(language: &str) -> Result<Vec<String>, String> {
-    let lang = language.to_lowercase();
-    let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources)?;
-    sources.sort();
-    if sources.is_empty() {
-        return Err("No source files found in ./src".to_string());
-    }
-    Ok(sources)
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    let extensions = source_extensions(ctx.language);
+    common::collect_sources(&extensions, ctx.exclude_dirs)
 }
 
-fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(), String> {
-    let entries = fs::read_dir(dir).map_err(|err| format!("src dir error: {err}"))?;
-    for entry in entries {
-        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
-        let path = entry.path();
-        if path.is_dir() {
-            collect_sources_rec(&path.to_string_lossy(), lang, out)?;
-            continue;
-        }
-        if !path.is_file() {
-            continue;
-        }
-        let ext = path
-            .extension()
-            .and_then(|v| v.to_str())
-            .unwrap_or("")
-            .to_lowercase();
-        let file = path.to_string_lossy().to_string();
-        let allowed = (lang == "c" && ext == "c")
-            || ((lang == "c++" || lang == "cpp" || lang == "cxx")
-                && (ext == "cpp" || ext == "cxx" || ext == "cc"));
-        if allowed {
-            out.push(file);
-        }
+fn source_extensions(language: &str) -> Vec<&str> {
+    let lang = language.to_lowercase();
+    match lang.as_str() {
+        "c" => vec!["c"],
+        "c++" | "cpp" | "cxx" => vec!["cpp", "cxx", "cc"],
+        _ => vec!["c"],
     }
-    Ok(())
 }
 
 fn msvc_standard_flag(language: &str, standard: &str) -> Result<String, String> {
@@ -154,10 +144,27 @@ fn msvc_standard_flag(language: &str, standard: &str) -> Result<String, String>
     Err("Unsupported language".to_string())
 }
 
+fn msvc_arch_flag(platform: Option<&str>) -> Option<&'static str> {
+    let raw = platform?.trim();
+    if raw.is_empty() {
+        return None;
+    }
+    let p = raw.to_lowercase().replace('-', "_");
+    if p == "x86" || (p.starts_with('i') && p.ends_with("86") && p.len() == 4) {
+        return Some("/arch:IA32");
+    }
+    match p.as_str() {
+        "sse2" => Some("/arch:SSE2"),
+        "avx" => Some("/arch:AVX"),
+        "avx2" => Some("/arch:AVX2"),
+        _ => None,
+    }
+}
+
 fn default_flags(profile: &str) -> &'static [&'static str] {
     match profile {
         "release" => &["/O2", "/DNDEBUG"],
-        "debug" => &["/Od", "/Zi", "/W4", "/DDEBUG", "/Oy-"],
+        "debug" => &["/Od", "/Zi", "/W4", "/DDCR_DEBUG", "/Oy-"],
         _ => &[],
     }
 }
@@ -171,11 +178,11 @@ fn build_objects(
 ) -> Result<Vec<String>, String> {
     let mut objects = Vec::new();
     for source in sources {
-        let obj_path = object_path(obj_dir, source, obj_ext);
+        let obj_path = common::object_path(obj_dir, source, obj_ext);
         if let Some(parent) = Path::new(&obj_path).parent() {
             fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
         }
-        if needs_rebuild(source, &obj_path) {
+        if common::needs_rebuild(source, &obj_path) {
             let mut cmd = Command::new(compiler);
             cmd.arg("/nologo");
             match ctx.language.to_lowercase().as_str() {
@@ -189,10 +196,13 @@ fn build_objects(
                     return Err("Unsupported language".to_string());
                 }
             }
-            if !ctx.standard.is_empty() {
+            if !ctx.standard.is_empty() && ctx.language.to_lowercase() != "asm" {
                 let std_flag = msvc_standard_flag(ctx.language, ctx.standard)?;
                 cmd.arg(std_flag);
             }
+            if let Some(flag) = msvc_arch_flag(ctx.platform) {
+                cmd.arg(flag);
+            }
             for flag in default_flags(ctx.profile) {
                 cmd.arg(flag);
             }
@@ -203,34 +213,57 @@ fn build_objects(
                 cmd.arg(format!("/I{dir}"));
             }
             cmd.arg("/c").arg(source).arg(format!("/Fo:{}", obj_path));
-            match cmd.status() {
-                Ok(status) if status.success() => {}
-                Ok(_) => return Err("Build failed".to_string()),
-                Err(err) => return Err(format!("Build failed: {err}")),
+            cmd.arg("/showIncludes");
+
+            if std::env::var("DCR_DEBUG").is_ok() {
+                eprintln!("[dcr] {:?}", cmd);
             }
+            let output = cmd.output().map_err(|err| format!("Build failed: {err}"))?;
+            let stdout = String::from_utf8_lossy(&output.stdout);
+            let stderr = String::from_utf8_lossy(&output.stderr);
+
+            let mut headers = Vec::new();
+            let mut clean_stdout = String::new();
+            for line in stdout.lines() {
+                if let Some(stripped) = line.strip_prefix("Note: including file:") {
+                    headers.push(stripped.trim().to_string());
+                } else if let Some(stripped) = line.strip_prefix("Примечание: включение файла:")
+                {
+                    headers.push(stripped.trim().to_string());
+                } else {
+                    clean_stdout.push_str(line);
+                    clean_stdout.push('\n');
+                }
+            }
+
+            if !output.status.success() {
+                eprint!("{}", clean_stdout);
+                eprint!("{}", stderr);
+                return Err("Build failed".to_string());
+            } else {
+                let trimmed_out = clean_stdout.trim();
+                let trimmed_err = stderr.trim();
+                let src_filename = Path::new(source)
+                    .file_name()
+                    .and_then(|v| v.to_str())
+                    .unwrap_or("");
+                if !trimmed_out.is_empty() && trimmed_out != src_filename {
+                    print!("{}", clean_stdout);
+                }
+                if !trimmed_err.is_empty() {
+                    eprintln!("{}", trimmed_err);
+                }
+            }
+
+            let d_path = Path::new(&obj_path).with_extension("d");
+            let mut d_content = format!("{}: \\\n", obj_path.replace('\\', "/"));
+            for h in headers {
+                let escaped = h.replace('\\', "/").replace(" ", "\\ ");
+                d_content.push_str(&format!("  {} \\\n", escaped));
+            }
+            std::fs::write(&d_path, d_content).map_err(|err| format!("d file error: {err}"))?;
         }
         objects.push(obj_path);
     }
     Ok(objects)
 }
-
-fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
-    let src_path = Path::new(source);
-    let rel = src_path
-        .strip_prefix("./src")
-        .or_else(|_| src_path.strip_prefix("src"))
-        .unwrap_or(src_path);
-    let mut out = obj_dir.join(rel);
-    out.set_extension(obj_ext.trim_start_matches('.'));
-    out.to_string_lossy().to_string()
-}
-
-fn needs_rebuild(source: &str, object: &str) -> bool {
-    let src_time = fs::metadata(source).and_then(|m| m.modified());
-    let obj_time = fs::metadata(object).and_then(|m| m.modified());
-    match (src_time, obj_time) {
-        (Ok(s), Ok(o)) => s > o,
-        (Ok(_), Err(_)) => true,
-        _ => true,
-    }
-}

src/core/builder/nasm.rs

@@ -0,0 +1,169 @@
+use crate::core::builder::BuildContext;
+use crate::core::builder::common;
+use crate::platform;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+use std::time::Instant;
+
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    if ctx.language.to_lowercase().as_str() != "asm" {
+        return Err("NASM backend requires build.language = \"asm\"".to_string());
+    }
+    let assembler = if ctx.compiler.is_empty() {
+        "nasm"
+    } else {
+        ctx.compiler
+    };
+    let start_time = Instant::now();
+    let sources = collect_sources(ctx)?;
+    let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
+    let objects = build_objects(assembler, &sources, &obj_dir, ctx, "o")?;
+
+    if ctx.kind == "staticlib" {
+        let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
+        let archiver = ctx.archiver.unwrap_or(if cfg!(target_os = "windows") {
+            "lib"
+        } else {
+            "ar"
+        });
+        let mut cmd = Command::new(archiver);
+        if cfg!(target_os = "windows") && archiver == "lib" {
+            cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
+        } else {
+            cmd.arg("rcs").arg(&lib_path);
+        }
+        for obj in &objects {
+            cmd.arg(obj);
+        }
+        if std::env::var("DCR_DEBUG").is_ok() {
+            eprintln!("[dcr] {:?}", cmd);
+        }
+        match cmd.status() {
+            Ok(status) if status.success() => {
+                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+                return Ok(elapsed);
+            }
+            Ok(_) => return Err("Build failed".to_string()),
+            Err(err) => return Err(format!("Build failed: {err}")),
+        }
+    }
+
+    let mut cmd = Command::new(ctx.linker.unwrap_or("cc"));
+    if ctx.kind == "sharedlib" {
+        if cfg!(target_os = "macos") {
+            cmd.arg("-dynamiclib");
+        } else {
+            cmd.arg("-shared");
+        }
+    }
+    for obj in &objects {
+        cmd.arg(obj);
+    }
+    for dir in ctx.lib_dirs {
+        cmd.arg(format!("-L{dir}"));
+    }
+    for lib in ctx.libs {
+        cmd.arg(format!("-l{lib}"));
+    }
+    for flag in ctx.ldflags {
+        cmd.arg(flag);
+    }
+    let out_path = if ctx.kind == "sharedlib" {
+        platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    } else {
+        platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    };
+    cmd.arg("-o").arg(out_path);
+
+    if std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+    match cmd.status() {
+        Ok(status) if status.success() => {
+            let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+            Ok(elapsed)
+        }
+        Ok(_) => Err("Build failed".to_string()),
+        Err(err) => Err(format!("Build failed: {err}")),
+    }
+}
+
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    // NASM handles lowercase .s and .asm only (not .S which is GCC preprocessed)
+    common::collect_sources(&["asm", "s"], ctx.exclude_dirs)
+}
+
+fn build_objects(
+    assembler: &str,
+    sources: &[String],
+    obj_dir: &Path,
+    ctx: &BuildContext,
+    obj_ext: &str,
+) -> Result<Vec<String>, String> {
+    let mut objects = Vec::new();
+    let format = nasm_format(ctx.platform);
+    for source in sources {
+        let obj_path = common::object_path(obj_dir, source, obj_ext);
+        if let Some(parent) = Path::new(&obj_path).parent() {
+            fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
+        }
+        if common::needs_rebuild(source, &obj_path) {
+            let mut cmd = Command::new(assembler);
+            cmd.arg("-f")
+                .arg(format)
+                .arg(source)
+                .arg("-o")
+                .arg(&obj_path);
+            for flag in ctx.cflags {
+                cmd.arg(flag);
+            }
+            if std::env::var("DCR_DEBUG").is_ok() {
+                eprintln!("[dcr] {:?}", cmd);
+            }
+            match cmd.status() {
+                Ok(status) if status.success() => {}
+                Ok(_) => return Err("Build failed".to_string()),
+                Err(err) => return Err(format!("Build failed: {err}")),
+            }
+        }
+        objects.push(obj_path);
+    }
+    Ok(objects)
+}
+
+fn nasm_format(platform: Option<&str>) -> &'static str {
+    if let Some(p) = platform {
+        let p = p.to_lowercase().replace('-', "_");
+        if p == "x86" || (p.starts_with('i') && p.ends_with("86") && p.len() == 4) {
+            #[cfg(target_os = "macos")]
+            {
+                return "macho32";
+            }
+            #[cfg(target_os = "windows")]
+            {
+                return "win32";
+            }
+            #[cfg(not(any(target_os = "macos", target_os = "windows")))]
+            {
+                return "elf32";
+            }
+        }
+    }
+    #[cfg(target_os = "linux")]
+    {
+        "elf64"
+    }
+    #[cfg(target_os = "macos")]
+    {
+        "macho64"
+    }
+    #[cfg(target_os = "windows")]
+    {
+        "win64"
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+    {
+        "elf64"
+    }
+}

src/core/builder/unix_cc.rs

@@ -1,4 +1,5 @@
 use crate::core::builder::BuildContext;
+use crate::core::builder::common;
 use crate::platform;
 use std::fs;
 use std::path::Path;
@@ -12,17 +13,21 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         ctx.compiler
     };
     let start_time = Instant::now();
-    let sources = collect_sources(ctx.language)?;
+    let extensions = source_extensions(ctx.language);
+    let sources = common::collect_sources(&extensions, ctx.exclude_dirs)?;
     let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
     let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o")?;
 
     if ctx.kind == "staticlib" {
         let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
-        let mut cmd = Command::new("ar");
+        let mut cmd = Command::new(ctx.archiver.unwrap_or("ar"));
         cmd.arg("rcs").arg(&lib_path);
         for obj in &objects {
             cmd.arg(obj);
         }
+        if std::env::var("DCR_DEBUG").is_ok() {
+            eprintln!("[dcr] {:?}", cmd);
+        }
         match cmd.status() {
             Ok(status) if status.success() => {
                 let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
@@ -33,16 +38,17 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         }
     }
 
-    let mut cmd = Command::new(compiler);
+    let mut cmd = Command::new(ctx.linker.unwrap_or(compiler));
+    if ctx.kind == "sharedlib" {
+        if cfg!(target_os = "macos") {
+            cmd.arg("-dynamiclib");
+        } else {
+            cmd.arg("-shared");
+        }
+    }
     for obj in &objects {
         cmd.arg(obj);
     }
-    for flag in default_flags(ctx.profile) {
-        cmd.arg(flag);
-    }
-    for flag in ctx.cflags {
-        cmd.arg(flag);
-    }
     for dir in ctx.lib_dirs {
         cmd.arg(format!("-L{dir}"));
     }
@@ -52,12 +58,16 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     for flag in ctx.ldflags {
         cmd.arg(flag);
     }
-    cmd.arg("-o").arg(platform::bin_path(
-        ctx.profile,
-        ctx.project_name,
-        ctx.target_dir,
-    ));
+    let out_path = if ctx.kind == "sharedlib" {
+        platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    } else {
+        platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
+    };
+    cmd.arg("-o").arg(out_path);
 
+    if std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
     match cmd.status() {
         Ok(status) if status.success() => {
             let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
@@ -68,43 +78,19 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
 }
 
-fn collect_sources(language: &str) -> Result<Vec<String>, String> {
-    let lang = language.to_lowercase();
-    let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources)?;
-    sources.sort();
-    if sources.is_empty() {
-        return Err("No source files found in ./src".to_string());
-    }
-    Ok(sources)
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    let extensions = source_extensions(ctx.language);
+    common::collect_sources(&extensions, ctx.exclude_dirs)
 }
 
-fn collect_sources_rec(dir: &str, lang: &str, out: &mut Vec<String>) -> Result<(), String> {
-    let entries = fs::read_dir(dir).map_err(|err| format!("src dir error: {err}"))?;
-    for entry in entries {
-        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
-        let path = entry.path();
-        if path.is_dir() {
-            collect_sources_rec(&path.to_string_lossy(), lang, out)?;
-            continue;
-        }
-        if !path.is_file() {
-            continue;
-        }
-        let ext = path
-            .extension()
-            .and_then(|v| v.to_str())
-            .unwrap_or("")
-            .to_lowercase();
-        let file = path.to_string_lossy().to_string();
-        let allowed = (lang == "c" && ext == "c")
-            || ((lang == "c++" || lang == "cpp" || lang == "cxx")
-                && (ext == "cpp" || ext == "cxx" || ext == "cc"));
-        if allowed {
-            out.push(file);
-        }
+fn source_extensions(language: &str) -> Vec<&str> {
+    let lang = language.to_lowercase();
+    match lang.as_str() {
+        "c" => vec!["c"],
+        "c++" | "cpp" | "cxx" => vec!["cpp", "cxx", "cc"],
+        "asm" => vec!["s", "S", "asm"],
+        _ => vec!["c"],
     }
-    Ok(())
 }
 
 fn default_flags(profile: &str) -> &'static [&'static str] {
@@ -116,7 +102,7 @@ fn default_flags(profile: &str) -> &'static [&'static str] {
             "-Wall",
             "-Wextra",
             "-fno-omit-frame-pointer",
-            "-DDEBUG",
+            "-DDCR_DEBUG",
         ],
         _ => &[],
     }
@@ -131,14 +117,25 @@ fn build_objects(
 ) -> Result<Vec<String>, String> {
     let mut objects = Vec::new();
     for source in sources {
-        let obj_path = object_path(obj_dir, source, obj_ext);
+        let obj_path = common::object_path(obj_dir, source, obj_ext);
         if let Some(parent) = Path::new(&obj_path).parent() {
             fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
         }
-        if needs_rebuild(source, &obj_path) {
+        if common::needs_rebuild(source, &obj_path) {
             let mut cmd = Command::new(compiler);
             cmd.arg("-c").arg(source).arg("-o").arg(&obj_path);
-            if !ctx.standard.is_empty() {
+            if ctx.kind == "sharedlib" {
+                cmd.arg("-fPIC");
+            }
+            if let Some(flag) = asm_lang_flag(source) {
+                cmd.arg("-x").arg(flag);
+            }
+            if let Some(platform) = ctx.platform
+                && !platform.trim().is_empty()
+            {
+                cmd.arg(format!("-march={}", platform));
+            }
+            if !ctx.standard.is_empty() && ctx.language.to_lowercase() != "asm" {
                 cmd.arg(format!("-std={}", ctx.standard));
             }
             for flag in default_flags(ctx.profile) {
@@ -150,6 +147,11 @@ fn build_objects(
             for dir in ctx.include_dirs {
                 cmd.arg(format!("-I{dir}"));
             }
+            let d_path = Path::new(&obj_path).with_extension("d");
+            cmd.arg("-MMD").arg("-MF").arg(&d_path);
+            if std::env::var("DCR_DEBUG").is_ok() {
+                eprintln!("[dcr] {:?}", cmd);
+            }
             match cmd.status() {
                 Ok(status) if status.success() => {}
                 Ok(_) => return Err("Build failed".to_string()),
@@ -161,23 +163,11 @@ fn build_objects(
     Ok(objects)
 }
 
-fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
-    let src_path = Path::new(source);
-    let rel = src_path
-        .strip_prefix("./src")
-        .or_else(|_| src_path.strip_prefix("src"))
-        .unwrap_or(src_path);
-    let mut out = obj_dir.join(rel);
-    out.set_extension(obj_ext.trim_start_matches('.'));
-    out.to_string_lossy().to_string()
-}
-
-fn needs_rebuild(source: &str, object: &str) -> bool {
-    let src_time = fs::metadata(source).and_then(|m| m.modified());
-    let obj_time = fs::metadata(object).and_then(|m| m.modified());
-    match (src_time, obj_time) {
-        (Ok(s), Ok(o)) => s > o,
-        (Ok(_), Err(_)) => true,
-        _ => true,
+fn asm_lang_flag(source: &str) -> Option<&'static str> {
+    let ext = Path::new(source).extension().and_then(|v| v.to_str())?;
+    match ext {
+        "S" => Some("assembler-with-cpp"),
+        "s" | "asm" => Some("assembler"),
+        _ => None,
     }
 }

src/core/config.rs

@@ -115,18 +115,36 @@ impl Config {
             .and_then(|v| v.as_table())
             .ok_or_else(|| ConfigError::Invalid("missing [build]".into()))?;
 
-        for key in ["language", "standard", "compiler", "kind"] {
+        for key in ["language", "standard", "compiler"] {
             let value = build.get(key).and_then(|v| v.as_str()).unwrap_or("");
             if value.trim().is_empty() {
                 return Err(ConfigError::Invalid(format!("build.{key} is empty")));
             }
         }
+        if let Some(platform) = build.get("platform")
+            && !platform
+                .as_str()
+                .map(|v| !v.trim().is_empty())
+                .unwrap_or(false)
+        {
+            return Err(ConfigError::Invalid("build.platform is empty".into()));
+        }
+        if let Some(toolchain) = self.get("toolchain").and_then(|v| v.as_table()) {
+            for key in ["cc", "cxx", "as", "ar", "ld"] {
+                if let Some(v) = toolchain.get(key)
+                    && !v.as_str().map(|s| !s.trim().is_empty()).unwrap_or(false)
+                {
+                    return Err(ConfigError::Invalid(format!("toolchain.{key} is invalid")));
+                }
+            }
+        }
         if let Some(kind) = build.get("kind").and_then(|v| v.as_str()) {
             let kind = kind.trim();
-            if kind != "bin" && kind != "staticlib" {
+            if !kind.is_empty() && kind != "bin" && kind != "staticlib" && kind != "sharedlib" {
                 return Err(ConfigError::Invalid("build.kind is invalid".into()));
             }
         }
+        self.validate_workspace()?;
         Ok(())
     }
 
@@ -142,6 +160,39 @@ impl Config {
     }
 }
 
+impl Config {
+    fn validate_workspace(&self) -> Result<(), ConfigError> {
+        let Some(workspace) = self.get("workspace").and_then(|v| v.as_table()) else {
+            return Ok(());
+        };
+        for (name, value) in workspace {
+            let tbl = value
+                .as_table()
+                .ok_or_else(|| ConfigError::Invalid(format!("workspace.{name} must be a table")))?;
+            let path = tbl.get("path").and_then(|v| v.as_str()).unwrap_or("");
+            if path.trim().is_empty() {
+                return Err(ConfigError::Invalid(format!(
+                    "workspace.{name}.path is empty"
+                )));
+            }
+            if let Some(deps) = tbl.get("deps") {
+                let arr = deps.as_array().ok_or_else(|| {
+                    ConfigError::Invalid(format!("workspace.{name}.deps must be array"))
+                })?;
+                for item in arr {
+                    let s = item.as_str().unwrap_or("");
+                    if s.trim().is_empty() {
+                        return Err(ConfigError::Invalid(format!(
+                            "workspace.{name}.deps contains empty value"
+                        )));
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
 fn read_toml(path: &Path) -> Result<Value, ConfigError> {
     let content = fs::read_to_string(path)?;
     Ok(toml::from_str(&content)?)
@@ -205,6 +256,7 @@ fn format_toml(value: &Value) -> Result<String, ConfigError> {
         .get("dependencies")
         .and_then(|v| v.as_table())
         .ok_or_else(|| ConfigError::Invalid("missing [dependencies]".into()))?;
+    let toolchain = root.get("toolchain").and_then(|v| v.as_table());
 
     let name = package.get("name").and_then(|v| v.as_str()).unwrap_or("");
     let version = package
@@ -243,6 +295,24 @@ fn format_toml(value: &Value) -> Result<String, ConfigError> {
     }
     out.push('\n');
 
+    if let Some(toolchain) = toolchain {
+        let mut lines = Vec::new();
+        for key in ["cc", "cxx", "as", "ar", "ld"] {
+            if let Some(value) = toolchain.get(key).and_then(|v| v.as_str())
+                && !value.trim().is_empty()
+            {
+                lines.push(format!("{key} = \"{value}\""));
+            }
+        }
+        if !lines.is_empty() {
+            out.push_str("[toolchain]\n");
+            for line in lines {
+                out.push_str(&format!("{line}\n"));
+            }
+            out.push('\n');
+        }
+    }
+
     out.push_str("[dependencies]\n");
     if !deps.is_empty() {
         let mut keys: Vec<&String> = deps.keys().collect();
@@ -323,3 +393,198 @@ fn set_path(value: &mut Value, path: &[&str], new_value: Value) -> Result<(), Co
         Err(ConfigError::Invalid("empty key".into()))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    static TEST_COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+    fn temp_dir(prefix: &str) -> PathBuf {
+        let n = TEST_COUNTER.fetch_add(1, Ordering::SeqCst);
+        let dir = std::env::temp_dir().join(format!("dcr_cfg_test_{prefix}_{n}"));
+        let _ = fs::remove_dir_all(&dir);
+        fs::create_dir_all(&dir).unwrap();
+        dir
+    }
+
+    fn write_toml_file(dir: &Path, content: &str) -> PathBuf {
+        let path = dir.join("dcr.toml");
+        fs::write(&path, content).unwrap();
+        path
+    }
+
+    fn minimal_valid_toml() -> &'static str {
+        "[package]\nname = \"test\"\nversion = \"0.1.0\"\n\n[build]\nlanguage = \"c\"\nstandard = \"c11\"\ncompiler = \"clang\"\nkind = \"bin\"\n\n[dependencies]\n"
+    }
+
+    #[test]
+    fn open_valid_toml() {
+        let dir = temp_dir("open_valid");
+        let path = write_toml_file(&dir, minimal_valid_toml());
+        let config = Config::open(&path.to_string_lossy());
+        assert!(config.is_ok(), "should open valid toml");
+    }
+
+    #[test]
+    fn open_invalid_toml_syntax() {
+        let dir = temp_dir("open_invalid");
+        let path = write_toml_file(&dir, "this is not [valid toml !!!");
+        let config = Config::open(&path.to_string_lossy());
+        assert!(config.is_err(), "should fail on invalid TOML syntax");
+    }
+
+    #[test]
+    fn open_nonexistent_fails() {
+        let result = Config::open("/tmp/dcr_nonexistent_file_12345.toml");
+        assert!(result.is_err(), "should fail on nonexistent file");
+    }
+
+    #[test]
+    fn validate_missing_package_fails() {
+        let dir = temp_dir("no_package");
+        let path = write_toml_file(
+            &dir,
+            "[build]\nlanguage = \"c\"\nstandard = \"c11\"\ncompiler = \"clang\"\n\n[dependencies]\n",
+        );
+        let result = Config::open(&path.to_string_lossy());
+        assert!(result.is_err(), "missing [package] should fail validation");
+    }
+
+    #[test]
+    fn validate_missing_build_fails() {
+        let dir = temp_dir("no_build");
+        let path = write_toml_file(
+            &dir,
+            "[package]\nname = \"test\"\nversion = \"0.1.0\"\n\n[dependencies]\n",
+        );
+        let result = Config::open(&path.to_string_lossy());
+        assert!(result.is_err(), "missing [build] should fail validation");
+    }
+
+    #[test]
+    fn validate_empty_language_fails() {
+        let dir = temp_dir("empty_lang");
+        let path = write_toml_file(
+            &dir,
+            "[package]\nname = \"test\"\nversion = \"0.1.0\"\n\n[build]\nlanguage = \"\"\nstandard = \"c11\"\ncompiler = \"clang\"\n\n[dependencies]\n",
+        );
+        let result = Config::open(&path.to_string_lossy());
+        assert!(result.is_err(), "empty language should fail validation");
+    }
+
+    #[test]
+    fn validate_unknown_kind_fails() {
+        let dir = temp_dir("bad_kind");
+        let path = write_toml_file(
+            &dir,
+            "[package]\nname = \"test\"\nversion = \"0.1.0\"\n\n[build]\nlanguage = \"c\"\nstandard = \"c11\"\ncompiler = \"clang\"\nkind = \"exe\"\n\n[dependencies]\n",
+        );
+        let result = Config::open(&path.to_string_lossy());
+        assert!(result.is_err(), "unknown kind 'exe' should fail validation");
+    }
+
+    #[test]
+    fn validate_valid_kinds() {
+        for kind in ["bin", "staticlib", "sharedlib"] {
+            let dir = temp_dir(&format!("kind_{kind}"));
+            let content = format!(
+                "[package]\nname = \"test\"\nversion = \"0.1.0\"\n\n[build]\nlanguage = \"c\"\nstandard = \"c11\"\ncompiler = \"clang\"\nkind = \"{kind}\"\n\n[dependencies]\n"
+            );
+            let path = write_toml_file(&dir, &content);
+            let result = Config::open(&path.to_string_lossy());
+            assert!(result.is_ok(), "kind '{kind}' should be valid");
+        }
+    }
+
+    #[test]
+    fn get_values() {
+        let dir = temp_dir("get_values");
+        let path = write_toml_file(&dir, minimal_valid_toml());
+        let config = Config::open(&path.to_string_lossy()).unwrap();
+
+        assert_eq!(
+            config.get("package.name").and_then(|v| v.as_str()),
+            Some("test")
+        );
+        assert_eq!(
+            config.get("build.language").and_then(|v| v.as_str()),
+            Some("c")
+        );
+        assert_eq!(
+            config.get("build.kind").and_then(|v| v.as_str()),
+            Some("bin")
+        );
+        assert!(config.get("nonexistent.key").is_none());
+    }
+
+    #[test]
+    fn set_and_read_back() {
+        let dir = temp_dir("set_value");
+        let path = write_toml_file(&dir, minimal_valid_toml());
+        let mut config = Config::open(&path.to_string_lossy()).unwrap();
+
+        config
+            .set("package.name", Value::String("newname".to_string()))
+            .unwrap();
+        assert_eq!(
+            config.get("package.name").and_then(|v| v.as_str()),
+            Some("newname")
+        );
+
+        // Verify persisted to disk
+        let config2 = Config::open(&path.to_string_lossy()).unwrap();
+        assert_eq!(
+            config2.get("package.name").and_then(|v| v.as_str()),
+            Some("newname")
+        );
+    }
+
+    #[test]
+    fn new_creates_default_config() {
+        let dir = temp_dir("new_default");
+        let path = dir.join("dcr.toml");
+        let config = Config::new(&path.to_string_lossy()).unwrap();
+
+        assert!(path.exists(), "dcr.toml should be created");
+        assert_eq!(
+            config.get("build.language").and_then(|v| v.as_str()),
+            Some("c")
+        );
+        assert_eq!(
+            config.get("build.standard").and_then(|v| v.as_str()),
+            Some("c11")
+        );
+        assert_eq!(
+            config.get("build.compiler").and_then(|v| v.as_str()),
+            Some("clang")
+        );
+        assert_eq!(
+            config.get("build.kind").and_then(|v| v.as_str()),
+            Some("bin")
+        );
+    }
+
+    #[test]
+    fn validate_workspace_empty_path_fails() {
+        let dir = temp_dir("ws_empty_path");
+        let path = write_toml_file(
+            &dir,
+            "[package]\nname = \"test\"\nversion = \"0.1.0\"\n\n[build]\nlanguage = \"c\"\nstandard = \"c11\"\ncompiler = \"clang\"\n\n[workspace]\n[workspace.member1]\npath = \"\"\n\n[dependencies]\n",
+        );
+        let result = Config::open(&path.to_string_lossy());
+        assert!(
+            result.is_err(),
+            "workspace member with empty path should fail"
+        );
+    }
+
+    #[test]
+    fn check_returns_bool() {
+        let dir = temp_dir("check_bool");
+        let path = write_toml_file(&dir, minimal_valid_toml());
+        let config = Config::open(&path.to_string_lossy()).unwrap();
+        assert!(config.check(), "valid config should return true");
+    }
+}

src/core/deps.rs

@@ -50,7 +50,8 @@ pub fn resolve_deps(
     let mut lock_packages = Vec::new();
 
     for dep in deps {
-        let dep_path = resolve_path(project_root, &dep.path_raw)?;
+        let dep_path_raw = expand_profile(&dep.path_raw, profile);
+        let dep_path = resolve_path(project_root, &dep_path_raw)?;
         if !dep_path.is_dir() {
             return Err(format!(
                 "Dependency '{}' path is not a directory: {}",
@@ -59,8 +60,13 @@ pub fn resolve_deps(
             ));
         }
 
-        let include = resolve_paths(&dep_path, dep.include_raw.as_deref(), &["include"])?;
-        let lib = resolve_paths(&dep_path, dep.lib_raw.as_deref(), &["lib", "lib64"])?;
+        let include = resolve_paths(&dep_path, dep.include_raw.as_deref(), &["include"], profile)?;
+        let lib = resolve_paths(
+            &dep_path,
+            dep.lib_raw.as_deref(),
+            &["lib", "lib64"],
+            profile,
+        )?;
         let libs_list = dep
             .libs_raw
             .clone()
@@ -200,11 +206,13 @@ fn resolve_paths(
     base: &Path,
     raw: Option<&[String]>,
     defaults: &[&str],
+    profile: &str,
 ) -> Result<Vec<PathBuf>, String> {
     let mut out = Vec::new();
     if let Some(raw) = raw {
         for r in raw {
-            let p = Path::new(r);
+            let expanded = expand_profile(r, profile);
+            let p = Path::new(&expanded);
             let full = if p.is_absolute() {
                 p.to_path_buf()
             } else {
@@ -227,6 +235,10 @@ fn resolve_paths(
     Ok(out)
 }
 
+fn expand_profile(raw: &str, profile: &str) -> String {
+    raw.replace("{profile}", profile)
+}
+
 fn sync_dep_dir(src: &Path, dst: &Path) -> std::io::Result<()> {
     if dst.exists() {
         fs::remove_dir_all(dst)?;

src/core/mod.rs

@@ -2,3 +2,4 @@ pub mod builder;
 pub mod config;
 pub mod deps;
 pub mod runner;
+pub mod workspace;

src/core/workspace.rs

@@ -0,0 +1,124 @@
+use crate::core::config::Config;
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+use toml::Value;
+
+#[derive(Debug, Clone)]
+pub struct WorkspaceMember {
+    pub name: String,
+    pub path: PathBuf,
+    pub deps: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Workspace {
+    pub members: Vec<WorkspaceMember>,
+}
+
+pub fn parse_workspace(config: &Config, root: &Path) -> Result<Option<Workspace>, String> {
+    let table = match config.get("workspace").and_then(|v| v.as_table()) {
+        Some(t) => t,
+        None => return Ok(None),
+    };
+
+    let mut members = Vec::new();
+    for (name, value) in table {
+        let tbl = value
+            .as_table()
+            .ok_or_else(|| format!("workspace.{name} must be a table with path and deps"))?;
+        let path_raw = tbl
+            .get("path")
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| format!("workspace.{name}.path is required"))?;
+        let path = resolve_path(root, path_raw)?;
+        if !path.join("dcr.toml").is_file() {
+            return Err(format!(
+                "workspace.{name}.path does not contain dcr.toml: {}",
+                path.display()
+            ));
+        }
+        let deps = parse_deps(tbl.get("deps"))?;
+        members.push(WorkspaceMember {
+            name: name.to_string(),
+            path,
+            deps,
+        });
+    }
+
+    let mut ws = Workspace { members };
+    ws.members = topo_sort(&ws.members)?;
+    Ok(Some(ws))
+}
+
+fn resolve_path(root: &Path, raw: &str) -> Result<PathBuf, String> {
+    let p = Path::new(raw);
+    let full = if p.is_absolute() {
+        p.to_path_buf()
+    } else {
+        root.join(p)
+    };
+    Ok(full)
+}
+
+fn parse_deps(value: Option<&Value>) -> Result<Vec<String>, String> {
+    let Some(value) = value else {
+        return Ok(Vec::new());
+    };
+    let arr = value
+        .as_array()
+        .ok_or_else(|| "workspace deps must be an array of strings".to_string())?;
+    let mut out = Vec::new();
+    for item in arr {
+        let s = item
+            .as_str()
+            .ok_or_else(|| "workspace deps must be an array of strings".to_string())?;
+        out.push(s.to_string());
+    }
+    Ok(out)
+}
+
+fn topo_sort(members: &[WorkspaceMember]) -> Result<Vec<WorkspaceMember>, String> {
+    let mut map = HashMap::new();
+    for m in members {
+        map.insert(m.name.clone(), m.clone());
+    }
+    let mut state: HashMap<String, u8> = HashMap::new();
+    let mut order: Vec<WorkspaceMember> = Vec::new();
+
+    for name in map.keys() {
+        if *state.get(name).unwrap_or(&0) == 0 {
+            visit(name, &map, &mut state, &mut order)?;
+        }
+    }
+    Ok(order)
+}
+
+fn visit(
+    name: &str,
+    map: &HashMap<String, WorkspaceMember>,
+    state: &mut HashMap<String, u8>,
+    order: &mut Vec<WorkspaceMember>,
+) -> Result<(), String> {
+    match state.get(name).copied().unwrap_or(0) {
+        1 => return Err(format!("workspace dependency cycle at {name}")),
+        2 => return Ok(()),
+        _ => {}
+    }
+    state.insert(name.to_string(), 1);
+    let member = map
+        .get(name)
+        .ok_or_else(|| format!("unknown workspace member {name}"))?;
+    let mut seen = HashSet::new();
+    for dep in &member.deps {
+        if !seen.insert(dep) {
+            continue;
+        }
+        if !map.contains_key(dep) {
+            return Err(format!("workspace dependency '{dep}' not found"));
+        }
+        visit(dep, map, state, order)?;
+    }
+    state.insert(name.to_string(), 2);
+    order.push(member.clone());
+    Ok(())
+}

src/platform/linux.rs

@@ -11,3 +11,64 @@ pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
         None => format!("./target/{profile}/lib{name}.a"),
     }
 }
+
+pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/lib{}.so", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/lib{name}.so"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn bin_path_default() {
+        assert_eq!(bin_path("debug", "hello", None), "./target/debug/hello");
+    }
+
+    #[test]
+    fn bin_path_release() {
+        assert_eq!(bin_path("release", "hello", None), "./target/release/hello");
+    }
+
+    #[test]
+    fn bin_path_custom_target() {
+        assert_eq!(bin_path("debug", "hello", Some("out")), "out/hello");
+    }
+
+    #[test]
+    fn bin_path_custom_target_trailing_slash() {
+        assert_eq!(bin_path("debug", "hello", Some("out/")), "out/hello");
+    }
+
+    #[test]
+    fn lib_path_default() {
+        assert_eq!(
+            lib_path("debug", "mylib", None),
+            "./target/debug/libmylib.a"
+        );
+    }
+
+    #[test]
+    fn lib_path_custom_target() {
+        assert_eq!(lib_path("debug", "mylib", Some("out")), "out/libmylib.a");
+    }
+
+    #[test]
+    fn shared_lib_path_default() {
+        assert_eq!(
+            shared_lib_path("debug", "mylib", None),
+            "./target/debug/libmylib.so"
+        );
+    }
+
+    #[test]
+    fn shared_lib_path_custom_target() {
+        assert_eq!(
+            shared_lib_path("release", "mylib", Some("dist")),
+            "dist/libmylib.so"
+        );
+    }
+}

src/platform/macos.rs

@@ -11,3 +11,10 @@ pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
         None => format!("./target/{profile}/lib{name}.a"),
     }
 }
+
+pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/lib{}.dylib", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/lib{name}.dylib"),
+    }
+}

src/platform/mod.rs

@@ -48,3 +48,25 @@ pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
         }
     }
 }
+
+pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    #[cfg(target_os = "linux")]
+    {
+        linux::shared_lib_path(profile, name, target_dir)
+    }
+    #[cfg(target_os = "macos")]
+    {
+        return macos::shared_lib_path(profile, name, target_dir);
+    }
+    #[cfg(target_os = "windows")]
+    {
+        return windows::shared_lib_path(profile, name, target_dir);
+    }
+    #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
+    {
+        match target_dir {
+            Some(dir) => format!("{}/lib{}.so", dir.trim_end_matches('/'), name),
+            None => format!("./target/{profile}/lib{name}.so"),
+        }
+    }
+}

src/platform/windows.rs

@@ -11,3 +11,10 @@ pub fn lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
         None => format!("./target/{profile}/{name}.lib"),
     }
 }
+
+pub fn shared_lib_path(profile: &str, name: &str, target_dir: Option<&str>) -> String {
+    match target_dir {
+        Some(dir) => format!("{}/{}.dll", dir.trim_end_matches('/'), name),
+        None => format!("./target/{profile}/{name}.dll"),
+    }
+}

src/utils/fs.rs

@@ -1,5 +1,5 @@
 use std::io;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 #[allow(dead_code)]
 pub fn check_dir(dir: Option<&str>) -> io::Result<Vec<String>> {
@@ -16,3 +16,16 @@ pub fn check_dir(dir: Option<&str>) -> io::Result<Vec<String>> {
 
     Ok(items)
 }
+
+pub fn find_project_root(start: &Path) -> io::Result<Option<PathBuf>> {
+    let mut current = start.to_path_buf();
+    loop {
+        if current.join("dcr.toml").is_file() {
+            return Ok(Some(current));
+        }
+        if !current.pop() {
+            break;
+        }
+    }
+    Ok(None)
+}

tests/cli_basic.rs

@@ -0,0 +1,220 @@
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::Once;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+static COUNTER: AtomicUsize = AtomicUsize::new(0);
+static BUILD_ONCE: Once = Once::new();
+
+fn bin_path() -> PathBuf {
+    if let Ok(exe) = std::env::var("CARGO_BIN_EXE_dcr") {
+        return PathBuf::from(exe);
+    }
+    ensure_bin_built();
+    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    path.push("target");
+    path.push("debug");
+    path.push(format!("dcr{}", std::env::consts::EXE_SUFFIX));
+    path
+}
+
+fn unique_sandbox_dir(prefix: &str) -> PathBuf {
+    let pid = std::process::id();
+    let n = COUNTER.fetch_add(1, Ordering::SeqCst);
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_nanos();
+    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    path.push("sandbox");
+    path.push("cli-tests");
+    path.push(format!("dcr_{prefix}_{pid}_{n}_{now}"));
+    std::fs::create_dir_all(&path).expect("failed to create temp dir");
+    path
+}
+
+fn run_dcr(args: &[&str], cwd: &Path) -> std::process::Output {
+    run_dcr_env(args, cwd, &[])
+}
+
+fn run_dcr_env(args: &[&str], cwd: &Path, envs: &[(&str, &str)]) -> std::process::Output {
+    let mut cmd = Command::new(bin_path());
+    cmd.args(args).current_dir(cwd);
+    for (k, v) in envs {
+        cmd.env(k, v);
+    }
+    cmd.output().expect("failed to run dcr")
+}
+
+fn ensure_bin_built() {
+    BUILD_ONCE.call_once(|| {
+        let status = Command::new("cargo")
+            .arg("build")
+            .current_dir(env!("CARGO_MANIFEST_DIR"))
+            .status()
+            .expect("failed to run cargo build");
+        assert!(status.success(), "cargo build failed");
+    });
+}
+
+fn available_compiler() -> Option<&'static str> {
+    for candidate in ["clang", "gcc", "cc"] {
+        let ok = Command::new(candidate)
+            .arg("--version")
+            .output()
+            .map(|o| o.status.success())
+            .unwrap_or(false);
+        if ok {
+            return Some(candidate);
+        }
+    }
+    None
+}
+
+#[test]
+fn help_and_version_work() {
+    let dir = unique_sandbox_dir("help");
+    let out = run_dcr(&["--help"], &dir);
+    assert!(out.status.success(), "--help should succeed");
+
+    let out = run_dcr(&["--version"], &dir);
+    assert!(out.status.success(), "--version should succeed");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(stdout.contains("dcr"), "version output should mention dcr");
+}
+
+#[test]
+fn new_creates_project_layout() {
+    let dir = unique_sandbox_dir("new");
+    let out = run_dcr(&["new", "hello"], &dir);
+    assert!(out.status.success(), "dcr new should succeed");
+
+    let project_dir = dir.join("hello");
+    assert!(project_dir.is_dir(), "project dir should exist");
+    assert!(project_dir.join("dcr.toml").is_file(), "dcr.toml missing");
+    assert!(
+        project_dir.join("src").join("main.c").is_file(),
+        "src/main.c missing"
+    );
+}
+
+#[test]
+fn init_and_clean_remove_target() {
+    let dir = unique_sandbox_dir("init");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "dcr init should succeed");
+
+    let target_debug = dir.join("target").join("debug");
+    std::fs::create_dir_all(&target_debug).expect("failed to create target/debug");
+    std::fs::write(target_debug.join("dummy.o"), "x").expect("failed to write dummy file");
+
+    let out = run_dcr(&["clean"], &dir);
+    assert!(out.status.success(), "dcr clean should succeed");
+    assert!(!dir.join("target").exists(), "target should be removed");
+}
+
+#[test]
+fn build_run_clean_flags_normal_project() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping build/run test");
+        return;
+    };
+
+    let dir = unique_sandbox_dir("normal");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "dcr init should succeed");
+
+    let envs = [("DCR_COMPILER", compiler)];
+    let out = run_dcr_env(&["build"], &dir, &envs);
+    assert!(out.status.success(), "dcr build should succeed");
+
+    let out = run_dcr_env(&["build", "--release"], &dir, &envs);
+    assert!(out.status.success(), "dcr build --release should succeed");
+
+    let out = run_dcr_env(&["run"], &dir, &envs);
+    assert!(out.status.success(), "dcr run should succeed");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(stdout.contains("Hello World!"), "run output missing");
+
+    let out = run_dcr_env(&["clean", "--release"], &dir, &envs);
+    assert!(out.status.success(), "dcr clean --release should succeed");
+    assert!(
+        !dir.join("target").join("release").exists(),
+        "target/release should be removed"
+    );
+    assert!(
+        dir.join("target").join("debug").is_dir(),
+        "target/debug should remain"
+    );
+
+    let out = run_dcr_env(&["clean"], &dir, &envs);
+    assert!(out.status.success(), "dcr clean should succeed");
+    assert!(!dir.join("target").exists(), "target should be removed");
+}
+
+#[test]
+fn workspace_build_and_clean_all() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping workspace test");
+        return;
+    };
+
+    let root = unique_sandbox_dir("workspace");
+    let out = run_dcr(&["init"], &root);
+    assert!(out.status.success(), "root init should succeed");
+
+    let members = [
+        ("userspace", &[][..]),
+        ("core", &["userspace"][..]),
+        ("kernel", &["core"][..]),
+    ];
+    for (name, _) in &members {
+        let member_dir = root.join("src").join(name);
+        std::fs::create_dir_all(&member_dir).expect("failed to create member dir");
+        let out = run_dcr(&["init"], &member_dir);
+        assert!(out.status.success(), "member init should succeed");
+    }
+
+    let workspace_toml = "[package]\nname = \"ws-root\"\nversion = \"0.1.0\"\n\n[build]\nlanguage = \"c\"\nstandard = \"c11\"\ncompiler = \"clang\"\nkind = \"bin\"\n\n[workspace]\nuserspace = { path = \"src/userspace\", deps = [] }\ncore = { path = \"src/core\", deps = [\"userspace\"] }\nkernel = { path = \"src/kernel\", deps = [\"core\"] }\n\n[dependencies]\n";
+    std::fs::write(root.join("dcr.toml"), workspace_toml).expect("failed to write root dcr.toml");
+
+    let envs = [("DCR_COMPILER", compiler)];
+    let out = run_dcr_env(&["build"], &root, &envs);
+    assert!(out.status.success(), "workspace build should succeed");
+
+    let out = run_dcr_env(&["build"], &root, &envs);
+    assert!(out.status.success(), "workspace build should succeed");
+
+    let out = run_dcr_env(&["build", "--release"], &root, &envs);
+    assert!(
+        out.status.success(),
+        "workspace build --release should succeed"
+    );
+
+    let out = run_dcr_env(&["clean", "--release", "--all"], &root, &envs);
+    assert!(
+        out.status.success(),
+        "workspace clean --all --release should succeed"
+    );
+
+    for (name, _) in &members {
+        let member = root.join("src").join(name);
+        assert!(
+            !member.join("target").join("release").exists(),
+            "member target/release should be removed"
+        );
+        assert!(
+            member.join("target").join("debug").exists(),
+            "member target/debug should remain"
+        );
+    }
+    assert!(
+        !root.join("target").join("release").exists(),
+        "root target/release should be removed"
+    );
+    assert!(
+        root.join("target").join("debug").exists(),
+        "root target/debug should remain"
+    );
+}

tests/cli_errors.rs

@@ -0,0 +1,297 @@
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::sync::Once;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+static COUNTER: AtomicUsize = AtomicUsize::new(0);
+static BUILD_ONCE: Once = Once::new();
+
+fn bin_path() -> PathBuf {
+    if let Ok(exe) = std::env::var("CARGO_BIN_EXE_dcr") {
+        return PathBuf::from(exe);
+    }
+    ensure_bin_built();
+    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    path.push("target");
+    path.push("debug");
+    path.push(format!("dcr{}", std::env::consts::EXE_SUFFIX));
+    path
+}
+
+fn unique_sandbox_dir(prefix: &str) -> PathBuf {
+    let pid = std::process::id();
+    let n = COUNTER.fetch_add(1, Ordering::SeqCst);
+    let now = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_nanos();
+    let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    path.push("sandbox");
+    path.push("cli-tests");
+    path.push(format!("dcr_{prefix}_{pid}_{n}_{now}"));
+    std::fs::create_dir_all(&path).expect("failed to create temp dir");
+    path
+}
+
+fn run_dcr(args: &[&str], cwd: &Path) -> std::process::Output {
+    let mut cmd = Command::new(bin_path());
+    cmd.args(args).current_dir(cwd);
+    cmd.output().expect("failed to run dcr")
+}
+
+fn run_dcr_env(args: &[&str], cwd: &Path, envs: &[(&str, &str)]) -> std::process::Output {
+    let mut cmd = Command::new(bin_path());
+    cmd.args(args).current_dir(cwd);
+    for (k, v) in envs {
+        cmd.env(k, v);
+    }
+    cmd.output().expect("failed to run dcr")
+}
+
+fn ensure_bin_built() {
+    BUILD_ONCE.call_once(|| {
+        let status = Command::new("cargo")
+            .arg("build")
+            .current_dir(env!("CARGO_MANIFEST_DIR"))
+            .status()
+            .expect("failed to run cargo build");
+        assert!(status.success(), "cargo build failed");
+    });
+}
+
+fn available_compiler() -> Option<&'static str> {
+    for candidate in ["clang", "gcc", "cc"] {
+        let ok = Command::new(candidate)
+            .arg("--version")
+            .output()
+            .map(|o| o.status.success())
+            .unwrap_or(false);
+        if ok {
+            return Some(candidate);
+        }
+    }
+    None
+}
+
+// --- Tests ---
+
+#[test]
+fn no_args_shows_help() {
+    let dir = unique_sandbox_dir("noargs");
+    let out = run_dcr(&[], &dir);
+    // Should succeed (help returns 0) and produce some output
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("DCR") || stdout.contains("dcr") || stdout.contains("USAGE"),
+        "no args should show help text"
+    );
+}
+
+#[test]
+fn unknown_command_fails() {
+    let dir = unique_sandbox_dir("unknown_cmd");
+    let out = run_dcr(&["foobar"], &dir);
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("error") || stdout.contains("Unknown"),
+        "unknown command should print error"
+    );
+}
+
+#[test]
+fn build_without_toml_fails() {
+    let dir = unique_sandbox_dir("build_no_toml");
+    let out = run_dcr(&["build"], &dir);
+    assert!(!out.status.success(), "build without dcr.toml should fail");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("dcr.toml") || stdout.contains("not found"),
+        "should mention missing dcr.toml"
+    );
+}
+
+#[test]
+fn run_without_toml_fails() {
+    let dir = unique_sandbox_dir("run_no_toml");
+    let out = run_dcr(&["run"], &dir);
+    assert!(!out.status.success(), "run without dcr.toml should fail");
+}
+
+#[test]
+fn clean_without_toml_fails() {
+    let dir = unique_sandbox_dir("clean_no_toml");
+    let out = run_dcr(&["clean"], &dir);
+    assert!(!out.status.success(), "clean without dcr.toml should fail");
+}
+
+#[test]
+fn new_existing_dir_fails() {
+    let dir = unique_sandbox_dir("new_exist");
+    // Create the project directory first
+    std::fs::create_dir_all(dir.join("hello")).expect("failed to create dir");
+    let out = run_dcr(&["new", "hello"], &dir);
+    assert!(!out.status.success(), "dcr new on existing dir should fail");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("already exists") || stdout.contains("error"),
+        "should report dir already exists"
+    );
+}
+
+#[test]
+fn init_nonempty_dir_fails() {
+    let dir = unique_sandbox_dir("init_nonempty");
+    // Put a file in the dir so it's not empty
+    std::fs::write(dir.join("dummy.txt"), "x").expect("failed to write");
+    let out = run_dcr(&["init"], &dir);
+    assert!(
+        !out.status.success(),
+        "dcr init in non-empty dir should fail"
+    );
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("not empty") || stdout.contains("error"),
+        "should report dir not empty"
+    );
+}
+
+#[test]
+fn build_unknown_flag_fails() {
+    let dir = unique_sandbox_dir("build_badflag");
+    // Init a valid project first
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "init should succeed");
+    let out = run_dcr(&["build", "--foobar"], &dir);
+    assert!(!out.status.success(), "build with unknown flag should fail");
+}
+
+#[test]
+fn run_library_project_fails() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping run_library test");
+        return;
+    };
+
+    let dir = unique_sandbox_dir("run_lib");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "init should succeed");
+
+    // Edit dcr.toml to set kind = "staticlib"
+    let toml_path = dir.join("dcr.toml");
+    let toml = std::fs::read_to_string(&toml_path).expect("failed to read dcr.toml");
+    let updated = toml.replace("kind = \"bin\"", "kind = \"staticlib\"");
+    std::fs::write(&toml_path, updated).expect("failed to write dcr.toml");
+
+    let envs = [("DCR_COMPILER", compiler)];
+    let out = run_dcr_env(&["run"], &dir, &envs);
+    assert!(!out.status.success(), "dcr run on staticlib should fail");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("library") || stdout.contains("Cannot run"),
+        "should report cannot run library"
+    );
+}
+
+#[test]
+fn clean_specific_profile() {
+    let dir = unique_sandbox_dir("clean_profile");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "init should succeed");
+
+    // Create target/debug and target/release dirs
+    std::fs::create_dir_all(dir.join("target").join("debug")).expect("create debug");
+    std::fs::write(dir.join("target").join("debug").join("dummy.o"), "x").expect("write");
+    std::fs::create_dir_all(dir.join("target").join("release")).expect("create release");
+    std::fs::write(dir.join("target").join("release").join("dummy.o"), "x").expect("write");
+
+    // Clean only release
+    let out = run_dcr(&["clean", "--release"], &dir);
+    assert!(out.status.success(), "clean --release should succeed");
+    assert!(
+        !dir.join("target").join("release").exists(),
+        "target/release should be removed"
+    );
+    assert!(
+        dir.join("target").join("debug").is_dir(),
+        "target/debug should remain"
+    );
+}
+
+#[test]
+fn new_no_name_fails() {
+    let dir = unique_sandbox_dir("new_noname");
+    let out = run_dcr(&["new"], &dir);
+    assert!(!out.status.success(), "dcr new without name should fail");
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("not specified") || stdout.contains("error"),
+        "should report name not specified"
+    );
+}
+
+#[test]
+fn staticlib_build() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping staticlib test");
+        return;
+    };
+    let dir = unique_sandbox_dir("staticlib");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "init should succeed");
+
+    let toml_path = dir.join("dcr.toml");
+    let toml = std::fs::read_to_string(&toml_path).expect("read dcr.toml");
+    let updated = toml.replace("kind = \"bin\"", "kind = \"staticlib\"");
+    std::fs::write(&toml_path, updated).expect("write dcr.toml");
+
+    let envs = [("DCR_COMPILER", compiler)];
+    let out = run_dcr_env(&["build"], &dir, &envs);
+    assert!(out.status.success(), "staticlib build should succeed");
+    // Check that a .a file exists
+    let lib_path = dir.join("target").join("debug");
+    let has_lib = std::fs::read_dir(&lib_path)
+        .map(|entries| {
+            entries
+                .filter_map(|e| e.ok())
+                .any(|e| e.file_name().to_string_lossy().ends_with(".a"))
+        })
+        .unwrap_or(false);
+    assert!(has_lib, "staticlib should produce a .a file");
+}
+
+#[test]
+fn build_release_profile() {
+    let Some(compiler) = available_compiler() else {
+        eprintln!("no compiler found; skipping release build test");
+        return;
+    };
+    let dir = unique_sandbox_dir("release_build");
+    let out = run_dcr(&["init"], &dir);
+    assert!(out.status.success(), "init should succeed");
+
+    let envs = [("DCR_COMPILER", compiler)];
+    let out = run_dcr_env(&["build", "--release"], &dir, &envs);
+    assert!(out.status.success(), "release build should succeed");
+    assert!(
+        dir.join("target").join("release").is_dir(),
+        "target/release should exist"
+    );
+}
+
+#[test]
+fn version_contains_version_string() {
+    let dir = unique_sandbox_dir("version");
+    let out = run_dcr(&["--version"], &dir);
+    assert!(out.status.success());
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    // Should contain version like "dcr 0.2.8 (target)"
+    assert!(
+        stdout.contains("dcr "),
+        "version output should start with 'dcr '"
+    );
+    assert!(
+        stdout.contains('.'),
+        "version output should contain a version number"
+    );
+}